package upgrade
|
|
import (
|
"basic.com/valib/version.git"
|
"context"
|
"basic.com/valib/logger.git"
|
"encoding/json"
|
"errors"
|
"fmt"
|
"github.com/gin-gonic/gin"
|
"gopkg.in/ini.v1"
|
"io"
|
"io/ioutil"
|
"net/http"
|
"os"
|
"path"
|
"sync"
|
"time"
|
"vamicro/update-service/models"
|
"vamicro/update-service/utils"
|
)
|
|
type (
|
UpgradeReply struct {
|
Status int
|
Body map[string]interface{}
|
}
|
|
UpgradePara struct {
|
Platform string
|
ArchiveFile *os.File
|
ReplyCh chan<- *UpgradeReply
|
Version string
|
Intro string
|
}
|
)
|
|
var (
|
msgCH chan *UpgradePara
|
)
|
|
func init() {
|
msgCH = make(chan *UpgradePara)
|
}
|
|
func Initialize(ctx context.Context, wg *sync.WaitGroup) {
|
wg.Add(1)
|
go msgLoop(ctx, wg)
|
}
|
|
func PUshMsg(msg *UpgradePara) {
|
msgCH <- msg
|
}
|
|
func msgLoop(ctx context.Context, wg *sync.WaitGroup) {
|
for {
|
select {
|
case <-ctx.Done():
|
logger.Info("upgrade msg loop canceled by user")
|
wg.Done()
|
return
|
case msg := <- msgCH:
|
code, body := doUpgrade(msg.Platform, msg.ArchiveFile, msg.Version, msg.Intro)
|
reply := &UpgradeReply {
|
Status: code,
|
Body: body,
|
}
|
msg.ReplyCh <- reply
|
}
|
}
|
}
|
|
func doUpgrade(arch string, f *os.File, version string, intro string) (int, map[string]interface{}) {
|
tempDir, err := ioutil.TempDir("", "dist-")
|
if nil != err {
|
body := map[string]interface{} {
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
}
|
logger.Error("doUpgrade create temp dire failed, err:", err.Error())
|
return http.StatusInternalServerError, body
|
}
|
logger.Info("doUpgrade tempDir:", tempDir)
|
|
//reopen later after debug
|
defer func() {
|
err = os.RemoveAll(tempDir)
|
}()
|
|
err = utils.DeCompressZip(f.Name(), tempDir)
|
if nil != err {
|
body := map[string]interface{} {
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
}
|
logger.Error("doUpgrade decompress failed, err:", err.Error())
|
return http.StatusBadRequest, body
|
}
|
|
newPrograms, err := packageAnalyze(tempDir)
|
if nil != err {
|
body := map[string]interface{} {
|
"code": http.StatusBadRequest,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
}
|
logger.Error("doUpgrade packageAnalyze failed, err:", err.Error())
|
return http.StatusBadRequest, body
|
}
|
|
if len(newPrograms) < 1 {
|
body := map[string]interface{} {
|
"code": http.StatusBadRequest,
|
"msg": "No valid programs to be upgrade",
|
"data": []*models.Program{},
|
}
|
logger.Error("doUpgrade No valid programs to be upgrade")
|
return http.StatusBadRequest, body
|
}
|
|
b, err := json.Marshal(newPrograms)
|
if nil == err {
|
logger.Info("doUpgrade marshal ok:", len(newPrograms), string(b))
|
} else {
|
logger.Info("doUpgrade marshal failed")
|
}
|
|
err = models.UpgradePrograms(arch, newPrograms)
|
if nil != err {
|
body := map[string]interface{} {
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": []*models.Program{},
|
}
|
logger.Error("doUpgrade commit updated failed, err:", err.Error())
|
return http.StatusInternalServerError, body
|
}
|
|
logger.Info("doUpgrade update db done")
|
|
updatedPrograms, err := models.FindAllPrograms(arch)
|
if nil != err {
|
body := map[string]interface{} {
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": &struct {
|
}{},
|
}
|
logger.Error("doUpgrade get old programs failed, err:", err.Error())
|
return http.StatusInternalServerError, body
|
}
|
|
b, err = json.Marshal(updatedPrograms)
|
if nil == err {
|
logger.Info("doUpgrade updatedPrograms marshal ok:", string(b))
|
} else {
|
logger.Info("doUpgrade updatedPrograms marshal failed")
|
}
|
|
distPath := utils.GetDistPath(arch)
|
tmpFile, err := ioutil.TempFile(distPath, "dist-*.zip")
|
if nil != err {
|
body := map[string]interface{} {
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": &struct {
|
}{},
|
}
|
logger.Error("doUpgrade create temp file failed, err:", err.Error())
|
return http.StatusInternalServerError, body
|
}
|
defer tmpFile.Close()
|
_, err = io.Copy(tmpFile, f)
|
if nil != err {
|
body := map[string]interface{} {
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": &struct {
|
}{},
|
}
|
logger.Error("doUpgrade create copy file failed, err:", err.Error())
|
return http.StatusInternalServerError, body
|
}
|
|
dist := &models.DistFile{
|
Platform: arch,
|
Timestamp: time.Now().UnixNano() / 1e6,
|
Path: tmpFile.Name(),
|
Version: version,
|
Intro: intro,
|
}
|
|
err = dist.Insert(models.GetDB())
|
if nil != err {
|
body := map[string]interface{} {
|
"code": http.StatusInternalServerError,
|
"msg": err.Error(),
|
"data": &struct {
|
}{},
|
}
|
logger.Error("doUpgrade insert db failed, err:", err.Error())
|
return http.StatusInternalServerError, body
|
}
|
|
return http.StatusOK, gin.H {
|
"code": http.StatusOK,
|
"msg": "ok",
|
"data": updatedPrograms,
|
}
|
}
|
|
func packageAnalyze(dir string) ([]*models.Program, error) {
|
manifestPath := path.Join(dir, "dist/bin/manifest.ini")
|
if _, err := os.Stat(manifestPath); os.IsNotExist(err) {
|
logger.Error("packageAnalyze manifest.ini not exist", err)
|
return nil, errors.New("failed to find manifest.ini in the archive file")
|
}
|
|
cfg, err := ini.Load(manifestPath)
|
if nil != err {
|
logger.Error("packageAnalyze failed to load manifest.ini", err)
|
return nil, errors.New("manifest.ini is invalid in the archive file")
|
}
|
|
sections := cfg.Sections()
|
if len(sections) < 1 {
|
logger.Error("No sections found in manifest.ini")
|
return nil, errors.New("No sections found in manifest.ini")
|
}
|
|
var arr []*models.Program
|
|
for _, s := range sections {
|
t := s.Key("Type").String()
|
if t != "app" {
|
continue
|
}
|
|
v := s.Key("Version").String()
|
_, err := vaversion.VersionName2VaVersion(v)
|
if nil != err {
|
msg := fmt.Sprint("invalid version in manifest.ini, ", "section:", s.Name(), "version:", v, err)
|
logger.Error("packageAnalyze version check msg:", msg)
|
return nil, errors.New(msg)
|
}
|
|
app := path.Join(dir, "dist/bin", s.Name())
|
if _, err := os.Stat(app); os.IsNotExist(err) {
|
msg := fmt.Sprint("app not exits in dist/bin, ", "app:", s.Name())
|
logger.Error("packageAnalyze app check msg:", msg)
|
return nil, errors.New(msg)
|
}
|
|
md5, err := utils.Md5sum(app)
|
if nil != err {
|
msg := fmt.Sprint("calculate md5sum failed, ", "app:", s.Name())
|
logger.Error("packageAnalyze md5sum check msg:", msg)
|
return nil, errors.New(msg)
|
}
|
|
buildTime := s.Key("BuildTime").String()
|
commitSha1 := s.Key("Commit").String()
|
p := &models.Program{
|
Name: s.Name(),
|
Version: v,
|
Md5sum: md5,
|
BuildTime: buildTime,
|
CommitSha1: commitSha1,
|
}
|
|
arr = append(arr, p)
|
}
|
|
return arr, nil
|
}
|
