301 lines
7.3 KiB
Go
301 lines
7.3 KiB
Go
package updater
|
|
|
|
import (
|
|
"archive/tar"
|
|
"archive/zip"
|
|
"compress/gzip"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"seanime/internal/util"
|
|
)
|
|
|
|
var (
|
|
ErrExtractionFailed = errors.New("could not extract assets")
|
|
)
|
|
|
|
// DownloadLatestRelease will download the latest release assets and extract them
|
|
// If the decompression fails, the returned string will be the directory to the compressed file
|
|
// If the decompression is successful, the returned string will be the directory to the extracted files
|
|
func (u *Updater) DownloadLatestRelease(assetUrl, dest string) (string, error) {
|
|
if u.LatestRelease == nil {
|
|
return "", errors.New("no new release found")
|
|
}
|
|
|
|
u.logger.Debug().Str("asset_url", assetUrl).Str("dest", dest).Msg("updater: Downloading latest release")
|
|
|
|
fpath, err := u.downloadAsset(assetUrl, dest)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
dest = filepath.Dir(fpath)
|
|
|
|
u.logger.Info().Str("dest", dest).Msg("updater: Downloaded release assets")
|
|
|
|
fp, err := u.decompressAsset(fpath, "")
|
|
if err != nil {
|
|
u.logger.Error().Err(err).Msg("updater: Failed to decompress release assets")
|
|
return fp, ErrExtractionFailed
|
|
}
|
|
dest = fp
|
|
|
|
u.logger.Info().Str("dest", dest).Msg("updater: Successfully decompressed downloaded release assets")
|
|
|
|
return dest, nil
|
|
}
|
|
|
|
func (u *Updater) DownloadLatestReleaseN(assetUrl, dest, folderName string) (string, error) {
|
|
if u.LatestRelease == nil {
|
|
return "", errors.New("no new release found")
|
|
}
|
|
|
|
u.logger.Debug().Str("asset_url", assetUrl).Str("dest", dest).Msg("updater: Downloading latest release")
|
|
|
|
fpath, err := u.downloadAsset(assetUrl, dest)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
dest = filepath.Dir(fpath)
|
|
|
|
u.logger.Info().Str("dest", dest).Msg("updater: Downloaded release assets")
|
|
|
|
fp, err := u.decompressAsset(fpath, folderName)
|
|
if err != nil {
|
|
u.logger.Error().Err(err).Msg("updater: Failed to decompress release assets")
|
|
return fp, err
|
|
}
|
|
dest = fp
|
|
|
|
u.logger.Info().Str("dest", dest).Msg("updater: Successfully decompressed downloaded release assets")
|
|
|
|
return dest, nil
|
|
}
|
|
|
|
func (u *Updater) decompressZip(archivePath string, folderName string) (dest string, err error) {
|
|
topFolderName := "seanime-" + u.LatestRelease.Version
|
|
if folderName != "" {
|
|
topFolderName = folderName
|
|
}
|
|
// "/seanime-repo/seanime-v1.0.0.zip" -> "/seanime-repo/seanime-1.0.0/"
|
|
dest = filepath.Join(filepath.Dir(archivePath), topFolderName) // "/seanime-repo/seanime-v1.0.0"
|
|
|
|
// Check if the destination folder already exists
|
|
if _, err := os.Stat(dest); err == nil {
|
|
return dest, errors.New("destination folder already exists")
|
|
}
|
|
|
|
// Create the destination folder
|
|
err = os.MkdirAll(dest, os.ModePerm)
|
|
if err != nil {
|
|
return dest, err
|
|
}
|
|
|
|
r, err := zip.OpenReader(archivePath)
|
|
if err != nil {
|
|
return dest, err
|
|
}
|
|
defer r.Close()
|
|
|
|
u.logger.Debug().Msg("updater: Decompressing release assets (zip)")
|
|
|
|
for _, f := range r.File {
|
|
fpath := filepath.Join(dest, f.Name)
|
|
if f.FileInfo().IsDir() {
|
|
os.MkdirAll(fpath, os.ModePerm)
|
|
continue
|
|
}
|
|
|
|
if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
|
|
return dest, err
|
|
}
|
|
|
|
outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
|
|
if err != nil {
|
|
return dest, err
|
|
}
|
|
|
|
rc, err := f.Open()
|
|
if err != nil {
|
|
outFile.Close()
|
|
return dest, err
|
|
}
|
|
|
|
_, err = io.Copy(outFile, rc)
|
|
outFile.Close()
|
|
rc.Close()
|
|
|
|
if err != nil {
|
|
return dest, err
|
|
}
|
|
}
|
|
|
|
r.Close()
|
|
|
|
err = os.Remove(archivePath)
|
|
if err != nil {
|
|
u.logger.Error().Err(err).Msg("updater: Failed to remove compressed file")
|
|
return dest, nil
|
|
}
|
|
|
|
u.logger.Debug().Msg("updater: Decompressed release assets (zip)")
|
|
|
|
return dest, nil
|
|
}
|
|
|
|
func (u *Updater) decompressTarGz(archivePath string, folderName string) (dest string, err error) {
|
|
topFolderName := "seanime-" + u.LatestRelease.Version
|
|
if folderName != "" {
|
|
topFolderName = folderName
|
|
}
|
|
dest = filepath.Join(filepath.Dir(archivePath), topFolderName)
|
|
|
|
if _, err := os.Stat(dest); err == nil {
|
|
return dest, errors.New("destination folder already exists")
|
|
}
|
|
|
|
err = os.MkdirAll(dest, os.ModePerm)
|
|
if err != nil {
|
|
return dest, err
|
|
}
|
|
|
|
file, err := os.Open(archivePath)
|
|
if err != nil {
|
|
return dest, err
|
|
}
|
|
defer file.Close()
|
|
|
|
gzr, err := gzip.NewReader(file)
|
|
if err != nil {
|
|
return dest, err
|
|
}
|
|
defer gzr.Close()
|
|
|
|
tr := tar.NewReader(gzr)
|
|
|
|
u.logger.Debug().Msg("updater: Decompressing release assets (gzip)")
|
|
|
|
for {
|
|
header, err := tr.Next()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
return dest, err
|
|
}
|
|
|
|
fpath := filepath.Join(dest, header.Name)
|
|
if header.Typeflag == tar.TypeDir {
|
|
if err := os.MkdirAll(fpath, os.ModePerm); err != nil {
|
|
return dest, err
|
|
}
|
|
} else {
|
|
if err := os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
|
|
return dest, err
|
|
}
|
|
|
|
outFile, err := os.Create(fpath)
|
|
if err != nil {
|
|
return dest, err
|
|
}
|
|
|
|
if _, err := io.Copy(outFile, tr); err != nil {
|
|
outFile.Close()
|
|
return dest, err
|
|
}
|
|
outFile.Close()
|
|
}
|
|
}
|
|
|
|
gzr.Close()
|
|
file.Close()
|
|
|
|
err = os.Remove(archivePath)
|
|
if err != nil {
|
|
u.logger.Error().Err(err).Msg("updater: Failed to remove compressed file")
|
|
return dest, nil
|
|
}
|
|
|
|
u.logger.Debug().Msg("updater: Decompressed release assets (gzip)")
|
|
|
|
return dest, nil
|
|
}
|
|
|
|
// decompressAsset will uncompress the release assets and delete the compressed folder
|
|
// - "/seanime-repo/seanime-v1.0.0.zip" -> "/seanime-repo/seanime-1.0.0/"
|
|
func (u *Updater) decompressAsset(archivePath string, folderName string) (dest string, err error) {
|
|
|
|
defer util.HandlePanicInModuleWithError("updater/download/decompressAsset", &err)
|
|
|
|
u.logger.Debug().Str("archive_path", archivePath).Msg("updater: Decompressing release assets")
|
|
|
|
ext := filepath.Ext(archivePath)
|
|
if ext == ".zip" {
|
|
return u.decompressZip(archivePath, folderName)
|
|
} else if ext == ".gz" {
|
|
return u.decompressTarGz(archivePath, folderName)
|
|
}
|
|
|
|
u.logger.Error().Msg("updater: Failed to decompress release assets, unsupported archive format")
|
|
|
|
return "", fmt.Errorf("unsupported archive format: %s", ext)
|
|
|
|
}
|
|
|
|
// downloadAsset will download the release assets to a folder
|
|
// - "seanime-v1.zip" -> "/seanime-repo/seanime-v1.zip"
|
|
func (u *Updater) downloadAsset(assetUrl, dest string) (fp string, err error) {
|
|
|
|
defer util.HandlePanicInModuleWithError("updater/download/downloadAsset", &err)
|
|
|
|
u.logger.Debug().Msg("updater: Downloading assets")
|
|
|
|
fp = u.getFilePath(assetUrl, dest)
|
|
|
|
// Get the data
|
|
resp, err := http.Get(assetUrl)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
// Check if the request was successful (status code 200)
|
|
if resp.StatusCode != http.StatusOK {
|
|
return "", fmt.Errorf("failed to download file, %s", resp.Status)
|
|
}
|
|
|
|
// Create the destination folder if it doesn't exist
|
|
err = os.MkdirAll(dest, os.ModePerm)
|
|
if err != nil {
|
|
u.logger.Error().Err(err).Msg("updater: Failed to download assets")
|
|
return "", err
|
|
}
|
|
|
|
// Create the file
|
|
out, err := os.Create(fp)
|
|
if err != nil {
|
|
u.logger.Error().Err(err).Msg("updater: Failed to download assets")
|
|
return "", err
|
|
}
|
|
defer out.Close()
|
|
|
|
// Write the body to file
|
|
_, err = io.Copy(out, resp.Body)
|
|
if err != nil {
|
|
u.logger.Error().Err(err).Msg("updater: Failed to download assets")
|
|
return "", err
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (u *Updater) getFilePath(url, dest string) string {
|
|
// Get the file name from the URL
|
|
fileName := filepath.Base(url)
|
|
return filepath.Join(dest, fileName)
|
|
}
|