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

269 lines
8.4 KiB
Go
Raw Normal View History

2023-01-30 21:05:20 +08:00
package service
import (
"encoding/json"
2023-01-30 21:05:20 +08:00
"fmt"
"io"
"net/http"
2023-01-30 21:05:20 +08:00
"os"
2023-08-01 22:05:14 +08:00
"path"
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/buserr"
"github.com/1Panel-dev/1Panel/backend/constant"
2023-01-30 21:05:20 +08:00
"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 releases-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 releases-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")
2023-08-01 22:05:14 +08:00
rootDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("upgrade/upgrade_%s/downloads", timeStr))
originalDir := path.Join(global.CONF.System.TmpDir, fmt.Sprintf("upgrade/upgrade_%s/original", 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-06-02 17:03:20 +08:00
itemArch, err := loadArch()
if 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)
2023-06-02 17:03:20 +08:00
fileName := fmt.Sprintf("1panel-%s-%s-%s.tar.gz", req.Version, "linux", itemArch)
2023-02-02 15:01:37 +08:00
_ = settingRepo.Update("SystemStatus", "Upgrading")
2023-01-30 21:05:20 +08:00
go func() {
_ = global.Cron.Stop()
defer func() {
global.Cron.Start()
}()
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!")
if err := cpBinary([]string{tmpDir + "/1panel"}, "/usr/local/bin/1panel"); err != nil {
2023-02-02 15:01:37 +08:00
global.LOG.Errorf("upgrade 1panel failed, err: %v", err)
2024-03-01 16:55:02 +08:00
u.handleRollback(originalDir, 1)
2023-01-30 21:05:20 +08:00
return
}
if err := cpBinary([]string{tmpDir + "/1pctl"}, "/usr/local/bin/1pctl"); err != nil {
2023-02-02 15:01:37 +08:00
global.LOG.Errorf("upgrade 1pctl failed, err: %v", err)
2024-03-01 16:55:02 +08:00
u.handleRollback(originalDir, 2)
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 {
global.LOG.Errorf("upgrade basedir in 1pctl failed, err: %v", err)
2024-03-01 16:55:02 +08:00
u.handleRollback(originalDir, 2)
return
}
if err := cpBinary([]string{tmpDir + "/1panel.service"}, "/etc/systemd/system/1panel.service"); err != nil {
2023-02-02 15:01:37 +08:00
global.LOG.Errorf("upgrade 1panel.service failed, err: %v", err)
2024-03-01 16:55:02 +08:00
u.handleRollback(originalDir, 3)
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")
checkPointOfWal()
_, _ = cmd.ExecWithTimeOut("systemctl daemon-reload && systemctl restart 1panel.service", 1*time.Minute)
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
}
2024-03-01 16:55:02 +08:00
func (u *UpgradeService) handleRollback(originalDir string, errStep int) {
2023-01-30 21:05:20 +08:00
dbPath := global.CONF.System.DbPath + "/1Panel.db"
_ = settingRepo.Update("SystemStatus", "Free")
if err := cpBinary([]string{originalDir + "/1Panel.db"}, dbPath); err != nil {
2023-01-30 21:05:20 +08:00
global.LOG.Errorf("rollback 1panel failed, err: %v", err)
}
if err := cpBinary([]string{originalDir + "/1panel"}, "/usr/local/bin/1panel"); err != nil {
2023-01-30 21:05:20 +08:00
global.LOG.Errorf("rollback 1pctl failed, err: %v", err)
}
if errStep == 1 {
return
}
if err := cpBinary([]string{originalDir + "/1pctl"}, "/usr/local/bin/1pctl"); err != nil {
2023-01-30 21:05:20 +08:00
global.LOG.Errorf("rollback 1panel failed, err: %v", err)
}
if errStep == 2 {
return
}
if err := cpBinary([]string{originalDir + "/1panel.service"}, "/etc/systemd/system/1panel.service"); err != nil {
2023-01-30 21:05:20 +08:00
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 "", buserr.New(constant.ErrOSSConn)
}
defer latestVersionRes.Body.Close()
version, err := io.ReadAll(latestVersionRes.Body)
if err != nil {
return "", buserr.New(constant.ErrOSSConn)
}
if isLatest {
return string(version), nil
}
versionMap := make(map[string]string)
if err := json.Unmarshal(version, &versionMap); err != nil {
return "", buserr.New(constant.ErrOSSConn)
}
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 "", buserr.New(constant.ErrOSSConn)
}
func (u *UpgradeService) loadReleaseNotes(path string) (string, error) {
releaseNotes, err := http.Get(path)
if err != nil {
return "", err
}
defer releaseNotes.Body.Close()
release, err := io.ReadAll(releaseNotes.Body)
if err != nil {
return "", err
}
return string(release), nil
2023-01-30 21:05:20 +08:00
}
2023-06-02 17:03:20 +08:00
func loadArch() (string, error) {
switch runtime.GOARCH {
case "amd64", "ppc64le", "s390x", "arm64":
return runtime.GOARCH, nil
case "arm":
std, err := cmd.Exec("uname -m")
if err != nil {
return "", fmt.Errorf("std: %s, err: %s", std, err.Error())
}
if std == "armv7l\n" {
return "armv7", nil
}
return "", fmt.Errorf("unsupported such arch: arm-%s", std)
2023-06-02 17:03:20 +08:00
default:
return "", fmt.Errorf("unsupported such arch: %s", runtime.GOARCH)
2023-06-02 17:03:20 +08:00
}
}