143 lines
3.6 KiB
Go
143 lines
3.6 KiB
Go
package spm
|
|
|
|
import (
|
|
"archive/tar"
|
|
"compress/gzip"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
// DecompressPackage now passes UpdateProgress to decompressTarGz.
|
|
func DecompressPackage(downloadDir, packageName, arch, osName, pkgType, release, version string) (string, error) {
|
|
// 1) Construct the .tar.gz name
|
|
expectedFileName := fmt.Sprintf(
|
|
"%s@%s@%s@%s@%s@%s.tar.gz",
|
|
packageName, arch, osName, pkgType, release, version,
|
|
)
|
|
packagePath := filepath.Join(downloadDir, expectedFileName)
|
|
|
|
// Check that file exists
|
|
if _, err := os.Stat(packagePath); os.IsNotExist(err) {
|
|
return "", fmt.Errorf("package file not found: %s", packagePath)
|
|
}
|
|
|
|
// 2) Build the folder path (minus ".tar.gz")
|
|
folderName := strings.TrimSuffix(expectedFileName, ".tar.gz")
|
|
tempDir := GetTempDir() // e.g. C:\Users\<User>\AppData\Local\Temp\spm_temp_164326
|
|
decompressDir := filepath.Join(tempDir, folderName)
|
|
|
|
// Ensure the folder
|
|
if err := os.MkdirAll(decompressDir, 0755); err != nil {
|
|
return "", fmt.Errorf("failed to create decompressDir: %w", err)
|
|
}
|
|
|
|
// 3) Decompress everything into `decompressDir`
|
|
if err := decompressTarGz(packagePath, decompressDir, UpdateProgress); err != nil {
|
|
return "", fmt.Errorf("failed to decompress: %w", err)
|
|
}
|
|
|
|
// Return the folder path we used
|
|
return decompressDir, nil
|
|
}
|
|
|
|
// decompressTarGz takes an additional updateProgress callback to report progress.
|
|
func decompressTarGz(srcFile, destDir string, updateProgress func(int, string)) error {
|
|
f, err := os.Open(srcFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer f.Close()
|
|
|
|
fileInfo, err := f.Stat()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
totalSize := fileInfo.Size()
|
|
|
|
// Wrap the file reader so we can track progress.
|
|
progressReader := &ProgressReader{
|
|
Reader: f,
|
|
Total: totalSize,
|
|
Callback: updateProgress,
|
|
}
|
|
|
|
gzr, err := gzip.NewReader(progressReader)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer gzr.Close()
|
|
|
|
tarReader := tar.NewReader(gzr)
|
|
for {
|
|
header, err := tarReader.Next()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
outPath := filepath.Join(destDir, header.Name)
|
|
switch header.Typeflag {
|
|
case tar.TypeDir:
|
|
if err := os.MkdirAll(outPath, os.FileMode(header.Mode)); err != nil {
|
|
return err
|
|
}
|
|
case tar.TypeReg:
|
|
outPath := filepath.Join(destDir, header.Name)
|
|
// Ensure the parent directory exists
|
|
if err := os.MkdirAll(filepath.Dir(outPath), 0755); err != nil {
|
|
return err
|
|
}
|
|
outFile, err := os.Create(outPath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = io.Copy(outFile, tarReader)
|
|
outFile.Close()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
default:
|
|
// ignoring other types for now
|
|
}
|
|
|
|
// Update progress after extracting each file.
|
|
if updateProgress != nil {
|
|
percent := int((progressReader.BytesRead * 100) / totalSize)
|
|
name := header.Name
|
|
if len(name) > 50 {
|
|
name = name[len(name)-50:]
|
|
}
|
|
updateProgress(percent, fmt.Sprintf("Extracted: %s", name))
|
|
}
|
|
}
|
|
|
|
// Final update: extraction complete.
|
|
if updateProgress != nil {
|
|
updateProgress(100, "Extraction complete")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// ProgressReader wraps an io.Reader to count bytes and update progress.
|
|
type ProgressReader struct {
|
|
io.Reader
|
|
Total int64
|
|
BytesRead int64
|
|
Callback func(int, string)
|
|
}
|
|
|
|
func (pr *ProgressReader) Read(p []byte) (int, error) {
|
|
n, err := pr.Reader.Read(p)
|
|
pr.BytesRead += int64(n)
|
|
if pr.Callback != nil && pr.Total > 0 {
|
|
percent := int((pr.BytesRead * 100) / pr.Total)
|
|
pr.Callback(percent, "Decompressing...")
|
|
}
|
|
return n, err
|
|
}
|