1Panel/backend/app/service/upgrade.go

240 lines
7.6 KiB
Go
Raw Normal View History

2023-01-30 21:05:20 +08:00
package service
import (
"encoding/json"
"errors"
2023-01-30 21:05:20 +08:00
"fmt"
"io/ioutil"
"net/http"
2023-01-30 21:05:20 +08:00
"os"
2023-02-05 23:48:37 +08:00
"runtime"
"strings"
2023-01-30 21:05:20 +08:00
"time"
"github.com/1Panel-dev/1Panel/backend/app/dto"
"github.com/1Panel-dev/1Panel/backend/global"
"github.com/1Panel-dev/1Panel/backend/utils/cmd"
2023-03-17 18:05:21 +08:00
"github.com/1Panel-dev/1Panel/backend/utils/common"
2023-01-30 21:05:20 +08:00
"github.com/1Panel-dev/1Panel/backend/utils/files"
)
type UpgradeService struct{}
type IUpgradeService interface {
2023-02-05 23:48:37 +08:00
Upgrade(req dto.Upgrade) error
LoadNotes(req dto.Upgrade) (string, error)
2023-01-30 21:05:20 +08:00
SearchUpgrade() (*dto.UpgradeInfo, error)
}
func NewIUpgradeService() IUpgradeService {
return &UpgradeService{}
}
func (u *UpgradeService) SearchUpgrade() (*dto.UpgradeInfo, error) {
var upgrade dto.UpgradeInfo
currentVersion, err := settingRepo.Get(settingRepo.WithByKey("SystemVersion"))
2023-01-30 21:05:20 +08:00
if err != nil {
return nil, err
}
latestVersion, err := u.loadVersion(true, currentVersion.Value)
if err != nil {
global.LOG.Infof("load latest version failed, err: %v", err)
return nil, err
2023-01-30 21:05:20 +08:00
}
if !common.CompareVersion(string(latestVersion), currentVersion.Value) {
return nil, err
2023-01-30 21:05:20 +08:00
}
upgrade.LatestVersion = latestVersion
if latestVersion[0:4] == currentVersion.Value[0:4] {
upgrade.NewVersion = ""
} else {
newerVersion, err := u.loadVersion(false, currentVersion.Value)
if err != nil {
global.LOG.Infof("load newer version failed, err: %v", err)
return nil, err
}
if newerVersion == currentVersion.Value {
upgrade.NewVersion = ""
} else {
upgrade.NewVersion = newerVersion
}
2023-01-30 21:05:20 +08:00
}
2023-03-24 11:52:10 +08:00
itemVersion := upgrade.LatestVersion
if upgrade.NewVersion != "" {
itemVersion = upgrade.NewVersion
}
notes, err := u.loadReleaseNotes(fmt.Sprintf("%s/%s/%s/release/1panel-%s-release-notes", global.CONF.System.RepoUrl, global.CONF.System.Mode, itemVersion, itemVersion))
if err != nil {
return nil, fmt.Errorf("load relase-notes of version %s failed, err: %v", latestVersion, err)
}
upgrade.ReleaseNote = notes
return &upgrade, nil
}
func (u *UpgradeService) LoadNotes(req dto.Upgrade) (string, error) {
notes, err := u.loadReleaseNotes(fmt.Sprintf("%s/%s/%s/release/1panel-%s-release-notes", global.CONF.System.RepoUrl, global.CONF.System.Mode, req.Version, req.Version))
if err != nil {
return "", fmt.Errorf("load relase-notes of version %s failed, err: %v", req.Version, err)
}
return notes, nil
2023-01-30 21:05:20 +08:00
}
2023-02-05 23:48:37 +08:00
func (u *UpgradeService) Upgrade(req dto.Upgrade) error {
2023-01-30 21:05:20 +08:00
global.LOG.Info("start to upgrade now...")
fileOp := files.NewFileOp()
timeStr := time.Now().Format("20060102150405")
rootDir := fmt.Sprintf("%s/upgrade_%s/downloads", global.CONF.System.TmpDir, timeStr)
originalDir := fmt.Sprintf("%s/upgrade_%s/original", global.CONF.System.TmpDir, timeStr)
2023-02-05 23:48:37 +08:00
if err := os.MkdirAll(rootDir, os.ModePerm); err != nil {
return err
}
if err := os.MkdirAll(originalDir, os.ModePerm); err != nil {
return err
}
2023-01-30 21:05:20 +08:00
downloadPath := fmt.Sprintf("%s/%s/%s/release", global.CONF.System.RepoUrl, global.CONF.System.Mode, req.Version)
fileName := fmt.Sprintf("1panel-%s-%s-%s.tar.gz", req.Version, "linux", runtime.GOARCH)
2023-02-02 15:01:37 +08:00
_ = settingRepo.Update("SystemStatus", "Upgrading")
2023-01-30 21:05:20 +08:00
go func() {
2023-03-14 16:45:32 +08:00
if err := fileOp.DownloadFile(downloadPath+"/"+fileName, rootDir+"/"+fileName); err != nil {
2023-02-05 23:48:37 +08:00
global.LOG.Errorf("download service file failed, err: %v", err)
_ = settingRepo.Update("SystemStatus", "Free")
2023-01-30 21:05:20 +08:00
return
}
2023-02-05 23:48:37 +08:00
global.LOG.Info("download all file successful!")
2023-01-30 21:05:20 +08:00
defer func() {
2023-02-05 23:48:37 +08:00
_ = os.Remove(rootDir)
2023-01-30 21:05:20 +08:00
}()
2023-03-14 16:45:32 +08:00
if err := handleUnTar(rootDir+"/"+fileName, rootDir); err != nil {
2023-02-02 15:01:37 +08:00
global.LOG.Errorf("decompress file failed, err: %v", err)
_ = settingRepo.Update("SystemStatus", "Free")
2023-01-30 21:05:20 +08:00
return
}
2023-03-14 16:45:32 +08:00
tmpDir := rootDir + "/" + strings.ReplaceAll(fileName, ".tar.gz", "")
2023-01-30 21:05:20 +08:00
if err := u.handleBackup(fileOp, originalDir); err != nil {
2023-02-02 15:01:37 +08:00
global.LOG.Errorf("handle backup original file failed, err: %v", err)
_ = settingRepo.Update("SystemStatus", "Free")
2023-01-30 21:05:20 +08:00
return
}
global.LOG.Info("backup original data successful, now start to upgrade!")
2023-03-14 16:45:32 +08:00
if err := cpBinary(tmpDir+"/1panel", "/usr/local/bin/1panel"); err != nil {
2023-01-30 21:05:20 +08:00
u.handleRollback(fileOp, originalDir, 1)
2023-02-02 15:01:37 +08:00
global.LOG.Errorf("upgrade 1panel failed, err: %v", err)
2023-01-30 21:05:20 +08:00
return
}
2023-03-14 16:45:32 +08:00
if err := cpBinary(tmpDir+"/1pctl", "/usr/local/bin/1pctl"); err != nil {
2023-01-30 21:05:20 +08:00
u.handleRollback(fileOp, originalDir, 2)
2023-02-02 15:01:37 +08:00
global.LOG.Errorf("upgrade 1pctl failed, err: %v", err)
2023-01-30 21:05:20 +08:00
return
}
if _, err := cmd.Execf("sed -i -e 's#BASE_DIR=.*#BASE_DIR=%s#g' /usr/local/bin/1pctl", global.CONF.System.BaseDir); err != nil {
u.handleRollback(fileOp, originalDir, 2)
global.LOG.Errorf("upgrade basedir in 1pctl failed, err: %v", err)
return
}
2023-03-14 16:45:32 +08:00
if err := cpBinary(tmpDir+"/1panel.service", "/etc/systemd/system/1panel.service"); err != nil {
2023-01-30 21:05:20 +08:00
u.handleRollback(fileOp, originalDir, 3)
2023-02-02 15:01:37 +08:00
global.LOG.Errorf("upgrade 1panel.service failed, err: %v", err)
2023-01-30 21:05:20 +08:00
return
}
global.LOG.Info("upgrade successful!")
go writeLogs(req.Version)
2023-02-05 23:48:37 +08:00
_ = settingRepo.Update("SystemVersion", req.Version)
_ = settingRepo.Update("SystemStatus", "Free")
_, _ = cmd.Exec("systemctl daemon-reload && systemctl restart 1panel.service")
2023-01-30 21:05:20 +08:00
}()
return nil
}
func (u *UpgradeService) handleBackup(fileOp files.FileOp, originalDir string) error {
if err := fileOp.Copy("/usr/local/bin/1panel", originalDir); err != nil {
return err
}
if err := fileOp.Copy("/usr/local/bin/1pctl", originalDir); err != nil {
return err
}
if err := fileOp.Copy("/etc/systemd/system/1panel.service", originalDir); err != nil {
return err
}
dbPath := global.CONF.System.DbPath + "/" + global.CONF.System.DbFile
if err := fileOp.Copy(dbPath, originalDir); err != nil {
return err
}
return nil
}
func (u *UpgradeService) handleRollback(fileOp files.FileOp, originalDir string, errStep int) {
dbPath := global.CONF.System.DbPath + "/1Panel.db"
_ = settingRepo.Update("SystemStatus", "Free")
2023-01-30 21:05:20 +08:00
if err := cpBinary(originalDir+"/1Panel.db", dbPath); err != nil {
global.LOG.Errorf("rollback 1panel failed, err: %v", err)
}
if err := cpBinary(originalDir+"/1panel", "/usr/local/bin/1panel"); err != nil {
global.LOG.Errorf("rollback 1pctl failed, err: %v", err)
}
if errStep == 1 {
return
}
if err := cpBinary(originalDir+"/1pctl", "/usr/local/bin/1pctl"); err != nil {
global.LOG.Errorf("rollback 1panel failed, err: %v", err)
}
if errStep == 2 {
return
}
if err := cpBinary(originalDir+"/1panel.service", "/etc/systemd/system/1panel.service"); err != nil {
global.LOG.Errorf("rollback 1panel failed, err: %v", err)
}
}
func (u *UpgradeService) loadVersion(isLatest bool, currentVersion string) (string, error) {
path := fmt.Sprintf("%s/%s/latest", global.CONF.System.RepoUrl, global.CONF.System.Mode)
if !isLatest {
path = fmt.Sprintf("%s/%s/latest.current", global.CONF.System.RepoUrl, global.CONF.System.Mode)
}
latestVersionRes, err := http.Get(path)
if err != nil {
return "", err
}
defer latestVersionRes.Body.Close()
version, err := ioutil.ReadAll(latestVersionRes.Body)
if err != nil {
return "", err
}
if isLatest {
return string(version), nil
}
versionMap := make(map[string]string)
if err := json.Unmarshal(version, &versionMap); err != nil {
return "", fmt.Errorf("load version map failed, err: %v", err)
}
if len(currentVersion) < 4 {
return "", fmt.Errorf("current version is error format: %s", currentVersion)
}
if version, ok := versionMap[currentVersion[0:4]]; ok {
return version, nil
}
return "", errors.New("load version failed in latest.current")
}
func (u *UpgradeService) loadReleaseNotes(path string) (string, error) {
releaseNotes, err := http.Get(path)
if err != nil {
return "", err
}
defer releaseNotes.Body.Close()
release, err := ioutil.ReadAll(releaseNotes.Body)
if err != nil {
return "", err
}
return string(release), nil
2023-01-30 21:05:20 +08:00
}