package service
|
|
import (
|
"basic.com/valib/bhomeclient.git"
|
"basic.com/valib/bhomedbapi.git"
|
"basic.com/valib/licence.git"
|
"basic.com/valib/logger.git"
|
"encoding/json"
|
"errors"
|
"fmt"
|
"io/ioutil"
|
"os"
|
"path"
|
"path/filepath"
|
"strconv"
|
"strings"
|
"time"
|
"vamicro/appcenter-service/models"
|
"vamicro/appcenter-service/vo"
|
"vamicro/config"
|
"vamicro/extend/util"
|
)
|
|
type SdkInstallService struct {
|
}
|
|
// inputTxt过滤条件
|
func (sv SdkInstallService) GetBuyList(inputTxt string) []SdkWithArg {
|
url := "http://" + util.GetShopUrl() + "/data/api-s/sdk/buyList"
|
machineCode := licence.GetMachineCode()
|
logger.Debug("url:", url, "machineCode:", machineCode)
|
var sdkE models.Sdk
|
localSdks, _ := sdkE.FindAll("") //本地已安装所有算法,带顺序
|
if localSdks == nil {
|
localSdks = make([]models.Sdk, 0)
|
}
|
iv := make(map[string]SdkVB)
|
|
localSdkIdArr := make([]string, 0)
|
for _, ls := range localSdks {
|
iv[ls.Id] = SdkVB{
|
Version: ls.Version,
|
BaseVersion: ls.BaseVersion,
|
}
|
|
localSdkIdArr = append(localSdkIdArr, ls.Id)
|
}
|
paramBody := map[string]interface{}{
|
"serverId": config.Server.AnalyServerId,
|
"machineCode": machineCode,
|
"localSdkIdArr": localSdkIdArr,
|
"iv": iv,
|
"inputTxt": inputTxt,
|
}
|
header := map[string]string{
|
"Authorization": token,
|
}
|
respBody, err := util.DoPostRequest(url, util.CONTENT_TYPE_JSON, paramBody, nil, header, time.Second*20)
|
if err != nil {
|
logger.Debug("DoPostRequest err:", err)
|
return nil
|
}
|
var res bhomedbapi.Result
|
if err = json.Unmarshal(respBody, &res); err != nil {
|
logger.Debug("unmarshal err:", err)
|
return nil
|
}
|
bytes, _ := json.Marshal(res.Data)
|
var ss shopSdks
|
if err := json.Unmarshal(bytes, &ss); err != nil {
|
logger.Debug("unmarshal err:", err)
|
return nil
|
}
|
|
var resultArr []SdkWithArg
|
|
installSdkM := make(map[string]models.Sdk)
|
if localSdks != nil {
|
for _, is := range localSdks {
|
installSdkM[is.Id] = is
|
}
|
}
|
if ss.Sdks != nil {
|
for _, rs := range ss.Sdks {
|
if _, ok := installSdkM[rs.Id]; !ok {
|
resultArr = append(resultArr, rs)
|
}
|
}
|
}
|
return resultArr
|
}
|
|
func (sv SdkInstallService) Active(cod string, sdkId string) (interface{}, error) {
|
//使用激活码激活算法
|
url := "http://" + util.GetShopUrl() + "/data/api-s/sdk/activeByAINode"
|
machineCode := licence.GetMachineCode()
|
if machineCode == "" {
|
logger.Debug("获取机器码失败")
|
return nil, errors.New("获取机器码失败")
|
}
|
paramBody := map[string]interface{}{
|
"code": cod,
|
"sdkId": sdkId,
|
"machineCode": machineCode,
|
"serverId": config.Server.AnalyServerId,
|
}
|
header := map[string]string{
|
"Authorization": token,
|
}
|
respBody, err := util.DoPostRequest(url, util.CONTENT_TYPE_JSON, paramBody, nil, header, time.Second*60)
|
if err != nil {
|
logger.Debug("DoPostRequest err:", err)
|
return nil, err
|
}
|
var res bhomedbapi.Result
|
if err = json.Unmarshal(respBody, &res); err != nil {
|
logger.Debug("unmarshal err:", err)
|
return nil, err
|
}
|
if !res.Success {
|
logger.Debug("Active Sdk ret false, res: ", res)
|
return nil, errors.New(res.Msg)
|
}
|
// 激活成功
|
return res.Data, nil
|
}
|
|
// 算法(应用)安装包安装
|
func (sv SdkInstallService) PackInstall(identifier string, filename string, h *bhomeclient.WrapperHandler) (bool, error) {
|
configPatchPath := ""
|
if config.Server.PatchPath != "" {
|
configPatchPath = config.Server.PatchPath
|
} else {
|
configPatchPath = "/opt/vasystem/patch"
|
}
|
|
filenameWithSuffix := path.Base(filename)
|
ext := path.Ext(filenameWithSuffix)
|
|
zipFilePath := configPatchPath + "/" + identifier + ext
|
unPackTargetPath := configPatchPath + "/" + identifier + "_basic/"
|
md5DirPath := configPatchPath + "/" + identifier
|
if util.Exists(zipFilePath) {
|
strMd5, e := util.FileMd5(zipFilePath)
|
if e != nil || strMd5 == "" {
|
go os.Remove(zipFilePath)
|
if util.DirExists(unPackTargetPath) {
|
go os.RemoveAll(unPackTargetPath)
|
}
|
if util.DirExists(md5DirPath) {
|
go os.RemoveAll(md5DirPath)
|
}
|
return false, errors.New("获取安装包md5失败")
|
}
|
if strMd5 == identifier {
|
if _, insE := installPack(identifier, ext, h); insE != nil {
|
logger.Error("PackInstall insE:", insE)
|
return false, insE
|
}
|
|
return true, nil
|
|
} else {
|
go os.Remove(zipFilePath)
|
if util.DirExists(unPackTargetPath) {
|
go os.RemoveAll(unPackTargetPath)
|
}
|
if util.DirExists(md5DirPath) {
|
go os.RemoveAll(md5DirPath)
|
}
|
logger.Debug("strMd5 is", strMd5, "identifier is", identifier, "not equal")
|
return false, errors.New("校验安装文件失败")
|
}
|
} else {
|
return false, errors.New("安装包已丢失，请重新上传")
|
}
|
}
|
|
func (sv SdkInstallService) PackUninstall(appId string) error {
|
uninstallFile := "/opt/vasystem/package/" + appId + "/uninstall.sh"
|
if util.Exists(uninstallFile) {
|
_, err := ExecCmd(uninstallFile)
|
if err != nil {
|
logger.Error("安装脚本执行失败:", err.Error())
|
return err
|
}
|
}
|
|
return nil
|
}
|
|
// 解压上传的算法安装包
|
func unPackPatchPackage(identifier string, ext string) (bool, error) {
|
if ext != ".gz" {
|
return false, errors.New("非法的安装包文件,安装包为.tar.gz文件")
|
}
|
configPatchPath := ""
|
if config.Server.PatchPath != "" {
|
configPatchPath = config.Server.PatchPath
|
} else {
|
configPatchPath = "/opt/vasystem/patch"
|
}
|
//1.解压缩更新包
|
unPackTargetPath := configPatchPath + "/" + identifier + "_basic/"
|
unPackFilePath := configPatchPath + "/" + identifier + ext
|
|
if util.Exists(unPackTargetPath) {
|
//此版本已经更新过
|
rmErr := os.RemoveAll(unPackTargetPath)
|
if rmErr != nil {
|
return false, rmErr
|
}
|
}
|
if !util.CreateDirectory(unPackTargetPath) {
|
return false, errors.New("创建压缩文件夹失败")
|
}
|
logger.Debug("unPackFilePath:", unPackFilePath, "unPackPath:", unPackTargetPath)
|
_, err := util.UnTarGzByCmd(unPackFilePath, unPackTargetPath)
|
if err != nil {
|
logger.Debug("UnPack err:", err, "unPackFile:", unPackFilePath)
|
return false, err
|
}
|
return true, nil
|
}
|
|
func (sv SdkInstallService) ShowInstallInfo(identifier string, filename string) (bool, map[string]interface{}, error) {
|
configPatchPath := ""
|
if config.Server.PatchPath != "" {
|
configPatchPath = config.Server.PatchPath
|
} else {
|
configPatchPath = "/opt/vasystem/patch"
|
}
|
unPackTargetPath := configPatchPath + "/" + identifier + "_basic/"
|
isValid := false
|
defer func() {
|
if !isValid {
|
filenameWithSuffix := path.Base(filename)
|
ext := path.Ext(filenameWithSuffix)
|
unPackFilePath := configPatchPath + "/" + identifier + ext
|
md5DirPath := configPatchPath + "/" + identifier
|
|
if util.Exists(unPackTargetPath) {
|
os.RemoveAll(unPackTargetPath)
|
}
|
if util.Exists(unPackFilePath) {
|
os.RemoveAll(unPackFilePath)
|
}
|
if util.DirExists(md5DirPath) {
|
go os.RemoveAll(md5DirPath)
|
}
|
|
}
|
}()
|
if util.Exists(unPackTargetPath) {
|
targetFileName := ""
|
err := filepath.Walk(unPackTargetPath, func(path string, f os.FileInfo, err error) error {
|
if f == nil {
|
return err
|
}
|
if f.IsDir() {
|
targetFileName = f.Name()
|
}
|
return nil
|
})
|
if err != nil {
|
return isValid, nil, errors.New("非法的安装包")
|
} else {
|
unPackPath := unPackTargetPath + targetFileName + "/"
|
//解压完成，获取安装包中的文件，开始安装
|
//1.解析安装说明ins.inc
|
incPath := unPackPath + "ins.inc"
|
if util.Exists(incPath) {
|
if incB, err := ioutil.ReadFile(incPath); err == nil {
|
var ins InsInc
|
if err = json.Unmarshal(incB, &ins); err == nil {
|
showInfo := map[string]interface{}{
|
"productName": ins.ProductName,
|
"installContent": ins.InstallContent,
|
}
|
sdkInfo := make([]map[string]interface{}, 0)
|
appInfo := make([]map[string]interface{}, 0)
|
if ins.Sdks != nil {
|
for _, is := range ins.Sdks {
|
sdkInfo = append(sdkInfo, map[string]interface{}{
|
"sdkId": is.SdkId,
|
"sdkName": is.SdkName,
|
"version": is.Version,
|
})
|
}
|
}
|
if ins.Modules != nil {
|
for _, ia := range ins.Modules {
|
appInfo = append(appInfo, map[string]interface{}{
|
"appId": ia.AppId,
|
"appName": ia.AppName,
|
"version": ia.Version,
|
})
|
}
|
}
|
showInfo["sdks"] = sdkInfo
|
showInfo["apps"] = appInfo
|
isValid = true
|
return true, showInfo, nil
|
} else {
|
return false, nil, errors.New("非法的安装包")
|
}
|
} else {
|
return false, nil, errors.New("非法的安装包")
|
}
|
} else {
|
return false, nil, errors.New("非法的安装包")
|
}
|
}
|
} else {
|
return isValid, nil, errors.New("非法的安装包格式，安装包已删除")
|
}
|
}
|
|
// 安装sdk(app)
|
func installPack(identifier string, ext string, h *bhomeclient.WrapperHandler) (bool, error) {
|
configPatchPath := ""
|
if config.Server.PatchPath != "" {
|
configPatchPath = config.Server.PatchPath
|
} else {
|
configPatchPath = "/opt/vasystem/patch"
|
}
|
//1.解压缩更新包
|
unPackTargetPath := configPatchPath + "/" + identifier + "_basic/"
|
unPackFilePath := configPatchPath + "/" + identifier + ext
|
md5DirPath := configPatchPath + "/" + identifier
|
defer func() {
|
if util.Exists(unPackTargetPath) {
|
os.RemoveAll(unPackTargetPath)
|
}
|
if util.Exists(unPackFilePath) {
|
os.RemoveAll(unPackFilePath)
|
}
|
if util.DirExists(md5DirPath) {
|
go os.RemoveAll(md5DirPath)
|
}
|
}()
|
|
if !util.Exists(unPackTargetPath) { //安装包不存在
|
return false, errors.New("解压后的安装文件已不存在")
|
}
|
|
// 查找下一级目录
|
targetDir := ""
|
files, err := ioutil.ReadDir(unPackTargetPath)
|
if err != nil {
|
return false, err
|
}
|
for _, f := range files {
|
if f.IsDir() && f.Name() != "." && f.Name() != ".." {
|
targetDir = f.Name()
|
}
|
}
|
|
if targetDir == "" {
|
return false, errors.New("安装目录不存在")
|
}
|
|
unPackPath := unPackTargetPath + targetDir + "/"
|
if !util.Exists(unPackPath) {
|
return false, errors.New("安装文件已不存在")
|
}
|
|
//解压完成，获取安装包中的文件，开始安装
|
//1.解析安装说明ins.inc
|
incPath := unPackPath + "ins.inc"
|
if util.Exists(incPath) {
|
if incB, err := ioutil.ReadFile(incPath); err == nil {
|
var ins InsInc
|
if err = json.Unmarshal(incB, &ins); err == nil {
|
|
// 定制手动安装
|
if ins.ActivateCode != "*" {
|
//处理授权信息,看当前安装包是否适用这台机器
|
curMc := licence.GetMachineCode()
|
curServerId := config.Server.AnalyServerId
|
devMatch := false
|
for _, mc := range ins.Devs {
|
if mc.DevId == curServerId || mc.MachineCode == curMc {
|
devMatch = true
|
break
|
}
|
}
|
if !devMatch {
|
logger.Debug("curServerId:", curServerId, "curMc:", curMc, "ins.Devs:", ins.Devs)
|
return false, errors.New("此安装包与当前设备不匹配，请检查")
|
}
|
}
|
|
//安装算法,如果有算法包
|
if len(ins.Sdks) > 0 {
|
if ie := installSDKInPack(unPackPath, ins.Sdks, h); ie != nil {
|
return false, errors.New("算法安装失败,失败原因:" + ie.Error() + "")
|
}
|
//如果有依赖文件则安装依赖
|
if depErr := installDepend(unPackPath); depErr != nil {
|
logger.Error("installDepend depErr:", depErr)
|
|
//如果安装包里没有带依赖或依赖安装失败，则尝试在线下载依赖
|
depErr = downloadDepend(ins.Sdks)
|
if depErr != nil {
|
logger.Error("downloadDepend err:", depErr)
|
}
|
}
|
}
|
|
//安装应用包，如果有应用
|
if len(ins.Modules) > 0 {
|
if ie := installAppInPack(unPackPath, ins.Modules, h); ie != nil {
|
return false, errors.New("应用安装失败,失败原因:" + ie.Error() + "")
|
}
|
}
|
} else {
|
logger.Debug("反序列化授权信息失败")
|
return false, errors.New("错误的安装包")
|
}
|
} else {
|
logger.Debug("读取授权文件失败")
|
return false, errors.New("错误的安装包")
|
}
|
} else {
|
return false, errors.New("错误的安装包")
|
}
|
|
return true, nil
|
}
|
|
// 安装安装包中的算法
|
func installSDKInPack(unPackPath string, sdkDefs []SdkIns, h *bhomeclient.WrapperHandler) error {
|
sv := NewSdkService(h.Bk)
|
var insErr error
|
var insSdkIds []string
|
defer func() {
|
if insErr != nil {
|
//todo 回滚
|
logger.Debug("installSDKInPack err:", insErr, "sdkIds:", insSdkIds)
|
if len(insSdkIds) > 0 {
|
//删除算法
|
//for _,id := range insSdkIds {
|
//
|
//}
|
}
|
}
|
}()
|
|
defSDKPath := unPackPath + "sdk.def"
|
if util.Exists(defSDKPath) {
|
if defB, err := ioutil.ReadFile(defSDKPath); err == nil {
|
//3.将算法so、依赖文件、zconf、
|
var skDefArr []SdkDef
|
if err = json.Unmarshal(defB, &skDefArr); err == nil {
|
exedFiles := make(map[string]string)
|
for _, sd := range sdkDefs {
|
//先校验platform是否匹配
|
if sd.Platform == "" {
|
insErr = errors.New("非法的安装包，无platform信息，请下载最新安装包")
|
return insErr
|
}
|
if !util.PlatformMatch(sd.Platform) {
|
insErr = errors.New("算法platform不匹配，非法的安装包")
|
return insErr
|
}
|
|
if sd.SdkBaseComponentPath != "" {
|
bPath := path.Base(sd.SdkBaseComponentPath)
|
if util.Exists(unPackPath + bPath) {
|
if _, nIn := exedFiles[bPath]; !nIn { //未安装过，才安装
|
//检查算法支持的显卡型号是否和本机匹配
|
if !util.GpuMatch(sd.VGpus) {
|
insErr = errors.New("算法支持的显卡型号(" + sd.VGpus + ")与当前设备不匹配")
|
return insErr
|
}
|
if insErr = installComponent(unPackPath, bPath); insErr != nil {
|
return insErr
|
} else {
|
exedFiles[bPath] = bPath
|
}
|
}
|
} else {
|
insErr = errors.New("基础算法包" + bPath + "丢失，请检查安装包")
|
return insErr
|
}
|
|
}
|
if sd.ComponentPath != "" {
|
oPath := path.Base(sd.ComponentPath)
|
if util.Exists(unPackPath + oPath) {
|
if _, nIn := exedFiles[oPath]; !nIn { //未安装过，才安装
|
if insErr = installComponent(unPackPath, oPath); insErr != nil {
|
return insErr
|
} else {
|
exedFiles[oPath] = oPath
|
}
|
}
|
} else {
|
insErr = errors.New("组件" + oPath + "丢失，请检查")
|
return insErr
|
}
|
}
|
}
|
|
for _, skd := range skDefArr {
|
srv := vo.SdkRegisterVo{}
|
srv.Id = skd.Def.Id
|
srv.SdkType = skd.Def.SdkType
|
srv.SdkName = skd.Def.SdkName
|
srv.Icon = skd.Def.Icon
|
srv.Url = skd.Def.Url
|
srv.IconBlob = skd.Def.IconBlob
|
srv.IconBlob2 = skd.Def.IconBlob2
|
srv.Version = skd.Def.Version
|
srv.EnTrack = skd.Def.EnTrack
|
srv.ArgDef = skd.Def.ArgDef
|
srv.RuleSo = skd.Def.RuleSo
|
srv.BaseVersion = skd.Def.BaseVersion
|
|
for _, ag := range skd.Args {
|
sra := vo.SdkRegisterArgVo{
|
Scope: ag.Scope,
|
}
|
sra.SdkArg = models.SdkArg{
|
Alias: ag.Alias,
|
Name: ag.Name,
|
Type: ag.Type,
|
ArgType: ag.ArgType,
|
Must: ag.Must,
|
Unit: ag.Unit,
|
Range: ag.Range,
|
DefaultValue: ag.DefaultValue,
|
DefaultOperator: ag.DefaultOperator,
|
Sort: ag.Sort,
|
}
|
srv.Args = append(srv.Args, sra)
|
}
|
//将算法注册到数据库中
|
if sv.Register(&srv) {
|
logger.Debug("注册成功，sdkId:", skd.Def.Id)
|
insSdkIds = append(insSdkIds, skd.Def.Id)
|
} else {
|
insErr = errors.New("sdk注册失败,算法id:" + skd.Def.Id + "")
|
logger.Debug(insErr.Error())
|
return insErr
|
}
|
}
|
//zconfPath := "./zconf/"
|
//libPath := "../libs/"
|
//if !util.DirExists(zconfPath) {
|
// os.MkdirAll(zconfPath, 0777)
|
//}
|
//if !util.DirExists(libPath) {
|
// os.MkdirAll(libPath, 0777)
|
//}
|
//for sdkType,_ := range soM {
|
// if _,iOk := nInsM[sdkType];iOk {
|
// //先解压SdkType.tar.gz文件
|
// if unTarGzE := util.UnTarGz(unPackPath+sdkType+".tar.gz", unPackPath);unTarGzE == nil {
|
// //复制json启动文件
|
// if util.Exists(unPackPath+sdkType+"/zconf/"+sdkType+".json") {
|
// util.CopyFile(unPackPath+sdkType+"/zconf/"+sdkType+".json", zconfPath+sdkType+".json")
|
// }
|
// if util.DirExists(unPackPath+sdkType) {
|
// if _,cE := util.CopyDirByCmd(unPackPath+sdkType, libPath);cE != nil {
|
// insErr = cE
|
// return insErr
|
// }
|
// }
|
// if util.DirExists(unPackPath+sdkType+"/models") {
|
// if _,cE := util.CopyDirByCmd(unPackPath+sdkType+"/models", "./"); cE != nil {
|
// insErr = cE
|
// return insErr
|
// }
|
// //拷贝完成后删除libs下sdkType文件夹下models
|
// }
|
// if util.DirExists(libPath+sdkType+"/models") {
|
// os.RemoveAll(libPath+sdkType+"/models")
|
// }
|
// if util.DirExists(libPath+sdkType+"/zconf") {
|
// os.RemoveAll(libPath+sdkType+"/zconf")
|
// }
|
// } else {
|
// logger.Debug("unTarGzE sdkType.tar.gz err:", unTarGzE)
|
// }
|
// } else {
|
// logger.Debug("upper version has been installed")
|
// }
|
//}
|
} else {
|
logger.Debug("反序列化算法定义信息失败")
|
insErr = errors.New("错误的安装包")
|
return insErr
|
}
|
} else {
|
logger.Debug("读取算法定义信息失败,err:", err)
|
insErr = errors.New("错误的安装包")
|
return insErr
|
}
|
} else {
|
insErr = errors.New("错误的安装包，算法定义文件不存在")
|
return insErr
|
}
|
|
return insErr
|
}
|
|
func installAppInPack(unPackPath string, appDefs []AppIns, h *bhomeclient.WrapperHandler) error {
|
//1.写入数据库
|
var appApi models.App
|
|
var insErr error
|
var insAppIds []string
|
defer func() {
|
if insErr != nil {
|
//todo 回滚
|
logger.Debug("installAppInPack err:", insErr, "appIds:", insAppIds)
|
if len(insAppIds) > 0 {
|
//删除应用
|
for _, id := range insAppIds {
|
appApi.DeleteById(id)
|
}
|
}
|
}
|
}()
|
|
defAppPath := unPackPath + "app.def"
|
if util.Exists(defAppPath) {
|
if defB, err := ioutil.ReadFile(defAppPath); err == nil {
|
//3.将算法so、依赖文件、zconf、
|
var appDefArr []models.App
|
if err = json.Unmarshal(defB, &appDefArr); err == nil {
|
var appId = ""
|
for _, ap := range appDefArr {
|
appId = ap.Id
|
if !SaveApp(ap) {
|
insErr = errors.New("注册应用失败，应用id:" + ap.Id + "")
|
return insErr
|
} else {
|
insAppIds = append(insAppIds, ap.Id)
|
}
|
}
|
|
//2.处理app文件内容
|
exedFiles := make(map[string]string)
|
for _, sd := range appDefs {
|
if sd.ComponentPath != "" {
|
oPath := path.Base(sd.ComponentPath)
|
if util.Exists(unPackPath + oPath) {
|
if _, nIn := exedFiles[oPath]; !nIn { //未安装过，才安装
|
insErr = installComponent(unPackPath, oPath)
|
if insErr != nil {
|
return insErr
|
} else {
|
exedFiles[oPath] = oPath
|
}
|
}
|
} else {
|
insErr = errors.New("组件" + oPath + "丢失，请检查")
|
return insErr
|
}
|
}
|
}
|
|
// 3 手动安装
|
installFile := path.Join(unPackPath, "install.sh")
|
if util.Exists(installFile) {
|
// 切换到当前运行目录
|
os.Chdir(unPackPath)
|
b, err := ExecCmd(installFile)
|
if err != nil {
|
logger.Error("安装脚本执行失败:", err.Error())
|
return err
|
}
|
logger.Debug("install component result:", string(b))
|
|
// 复制安装文件到package目录, 卸载时调用 uninstall
|
pkgDir := "/opt/vasystem/package/" + appId
|
ExecCmd(fmt.Sprintf("mkdir -p %s", pkgDir))
|
ExecCmd(fmt.Sprintf("cp -rf %s/* %s/", unPackPath, pkgDir))
|
|
return nil
|
}
|
} else {
|
logger.Debug("反序列化应用定义信息失败")
|
insErr = errors.New("错误的安装包")
|
return insErr
|
}
|
} else {
|
insErr = errors.New("读取应用定义文件失败")
|
return insErr
|
}
|
} else {
|
insErr = errors.New("错误的安装包，应用定义文件不存在")
|
return insErr
|
}
|
|
return nil
|
}
|
|
func installComponent(unPackPath string, componentFileName string) error {
|
ext := path.Ext(componentFileName)
|
if ext == "" {
|
return errors.New("非法的安装包后缀")
|
}
|
cName := strings.ReplaceAll(componentFileName, ext, "")
|
targetPath := unPackPath + cName + "/"
|
logger.Debug("installComponent targetPath:", targetPath)
|
if util.Exists(targetPath) {
|
rmErr := os.RemoveAll(targetPath)
|
if rmErr != nil {
|
return rmErr
|
}
|
}
|
if !util.CreateDirectory(targetPath) {
|
return errors.New("创建压缩文件夹失败")
|
}
|
if utzOut, unTarGzE := util.UnTarGzByCmd(unPackPath+componentFileName, targetPath); unTarGzE == nil {
|
//使用安装脚本执行
|
//targetFileName := ""
|
//err := filepath.Walk(targetPath, func(path string, f os.FileInfo, err error) error {
|
// if f == nil {
|
// return err
|
// }
|
// if f.IsDir() {
|
// targetFileName = f.Name()
|
// }
|
// return nil
|
//})
|
//if err != nil {
|
// return errors.New("安装包不合法，请检查，err:"+err.Error()+"")
|
//}
|
//logger.Debug("targetFileName:", targetFileName)
|
if util.Exists(targetPath + "install.sh") {
|
cmdPath := fmt.Sprintf("%sinstall.sh %s", targetPath, targetPath)
|
b, err := ExecCmd(cmdPath)
|
if err != nil {
|
return err
|
}
|
logger.Debug("install component ", componentFileName, " result:", string(b))
|
return nil
|
} else {
|
return errors.New("安装执行文件不存在，请检查")
|
}
|
} else {
|
logger.Error("UnTarGzByCmd out:", utzOut)
|
return unTarGzE
|
}
|
}
|
|
func shouldVersionBeUpgrade(curVersion, dstVersion string) bool {
|
if curVersion == "" {
|
return true
|
}
|
if dstVersion == "" {
|
return false
|
}
|
curIVArr := strings.Split(curVersion, ".")
|
dstIVArr := strings.Split(dstVersion, ".")
|
if len(curIVArr) != 3 || len(dstIVArr) != 3 {
|
return false
|
}
|
cH, cEH := strconv.Atoi(curIVArr[0])
|
cM, cEM := strconv.Atoi(curIVArr[1])
|
cL, cEL := strconv.Atoi(curIVArr[2])
|
|
dH, dEH := strconv.Atoi(dstIVArr[0])
|
dM, dEM := strconv.Atoi(dstIVArr[1])
|
dL, dEL := strconv.Atoi(dstIVArr[2])
|
if cEH != nil || cEM != nil || cEL != nil || dEH != nil || dEM != nil || dEL != nil {
|
return false
|
}
|
if cH > dH {
|
return false
|
} else if cH == dH {
|
if cM > dM {
|
return false
|
} else if cM == dM {
|
if cL > dL {
|
return false
|
} else if cL == dL {
|
return false
|
} else {
|
return true
|
}
|
} else {
|
return true
|
}
|
} else {
|
return true
|
}
|
}
|
|
type InsInc struct {
|
OrderId string `json:"orderId"` //订单id
|
ProductId string `json:"productId"` //产品id
|
ActivateCode string `json:"activateCode"` //激活码
|
Devs []InsDev `json:"devs"` //安装包给哪些设备使用
|
UserId string `json:"userId"` //用户id
|
Sdks []SdkIns `json:"sdks"` //算法模块
|
Modules []AppIns `json:"modules"` //应用模块
|
ChCount int `json:"chCount"` //通道数量
|
AuthCount int `json:"authCount"` //授权数量
|
ServeYear int `json:"serveYear"` //服务时长
|
|
ProductName string `json:"productName"`
|
InstallContent string `json:"installContent"`
|
}
|
|
type InsDev struct {
|
DevId string `json:"devId"`
|
MachineCode string `json:"machineCode"`
|
}
|
|
type SdkIns struct {
|
SdkId string `json:"sdkId"`
|
SdkName string `json:"sdkName"`
|
SdkType string `json:"sdkType"`
|
Version string `json:"version"`
|
BaseVersion string `json:"baseVersion"`
|
SdkBaseComponentPath string `json:"sdkBase_component_path"`
|
SdkBaseComponentName string `json:"sdkBase_component_name"`
|
ComponentPath string `json:"component_path"`
|
ComponentName string `json:"component_name"`
|
VGpus string `json:"vGpus"` //此算法支持的显卡型号
|
Platform string `json:"platform"`
|
}
|
|
type AppIns struct {
|
AppId string `json:"appId"`
|
AppName string `json:"appName"`
|
Version string `json:"version"`
|
ComponentPath string `json:"component_path"`
|
ComponentName string `json:"component_name"`
|
}
|
|
// 算法和参数定义
|
type SdkDef struct {
|
Def models.Sdk `json:"def"`
|
Args []models.SdkArgEntity `json:"args"`
|
}
|
|
type SdkWithArg struct {
|
models.Sdk
|
Args []models.SdkArgEntity `json:"args"`
|
CanUpOrIns bool `json:"canUpOrIns"`
|
Platforms []models.PtIns `json:"platforms"` //可适配的平台信息
|
}
|
|
type SdkInsOrUpgrade struct {
|
SdkWithArg
|
|
RemoteVersion string `json:"remoteVersion"` //商城仓库版本号
|
Installed bool `json:"installed"` //是否已安装
|
IsUpgrade bool `json:"isUpgrade"` //是否需要升级
|
ProgressMsg string `json:"progressMsg"` //安装或升级进度
|
ProtoRuleSo string `json:"ruleSo"` //适配protomsg中的ruleSo
|
}
|
