package service
|
|
import (
|
"basic.com/dbapi.git"
|
"basic.com/pubsub/protomsg.git"
|
"basic.com/valib/licence.git"
|
"basic.com/valib/logger.git"
|
"encoding/json"
|
"errors"
|
"io/ioutil"
|
"os"
|
"path"
|
"path/filepath"
|
"strconv"
|
"strings"
|
"webserver/extend/config"
|
"webserver/extend/util"
|
reqUtil "webserver/extend/util"
|
)
|
|
type SdkInstallService struct {
|
|
}
|
|
func (sv SdkInstallService) Active(cod string, sdkId string) (interface{},error) {
|
//使用激活码激活算法
|
url := "http://"+config.ShopConf.Url+"/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,
|
}
|
header := map[string]string {
|
"Authorization": token,
|
}
|
respBody, err := reqUtil.DoPostRequest(url, reqUtil.CONTENT_TYPE_JSON, paramBody, nil, header)
|
if err != nil {
|
logger.Debug("DoPostRequest err:", err)
|
return nil, err
|
}
|
var res dbapi.Result
|
if err = json.Unmarshal(respBody, &res); err != nil {
|
logger.Debug("unmarshal err:", err)
|
return nil, err
|
}
|
if !res.Success {
|
logger.Debug("res.Data:", res.Data)
|
return nil, errors.New("请求商城失败")
|
}
|
|
return res.Data, nil
|
}
|
|
//算法安装包安装
|
func (sv SdkInstallService) SdkInstall(identifier string,filename string) (bool,error) {
|
configPatchPath := ""
|
if config.Server.PatchPath != "" {
|
configPatchPath = config.Server.PatchPath
|
} else {
|
configPatchPath = "../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 := installSdk(identifier, ext); insE != nil {
|
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 unPackPatchPackage(identifier string, ext string) (bool,error) {
|
configPatchPath := ""
|
if config.Server.PatchPath != "" {
|
configPatchPath = config.Server.PatchPath
|
} else {
|
configPatchPath = "../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 = "../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 {
|
return true, map[string]interface{} {
|
"sdkName": ins.ProductName,
|
"installVersion": ins.InstallVersion,
|
"installContent": ins.InstallContent,
|
}, 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
|
func installSdk(identifier string, ext string) (bool, error) {
|
configPatchPath := ""
|
if config.Server.PatchPath != "" {
|
configPatchPath = config.Server.PatchPath
|
} else {
|
configPatchPath = "../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("安装文件已不存在")
|
}
|
|
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 false, err
|
}
|
unPackPath := unPackTargetPath + targetFileName +"/"
|
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 {
|
//处理授权信息
|
curMc := ""
|
if ins.MachineCode != curMc {
|
|
}
|
//2.解析sdk.def,将so和zconf复制到/opt/vasystem/libs/文件夹下
|
defPath := unPackPath + "sdk.def"
|
if util.Exists(defPath) {
|
if defB, err := ioutil.ReadFile(defPath); err == nil {
|
//3.将算法so、依赖文件、zconf、
|
soM := make(map[string]SdkDef)
|
var skDefArr []SdkDef
|
nInsM := make(map[string]string)
|
aInsM := make(map[string]string)
|
if err = json.Unmarshal(defB, &skDefArr);err == nil {
|
var sdkApi dbapi.SdkApi
|
for _,skd := range skDefArr {
|
//注册算法信息和算法参数到dbserver
|
//先看此算法有没有注册，如果已安装，比对版本号
|
bf, curDbSdk := sdkApi.GetById(skd.Def.Id)
|
if bf {
|
bytes, _ := json.Marshal(curDbSdk)
|
var sm map[string]interface{}
|
unE := json.Unmarshal(bytes, &sm)
|
if unE != nil {
|
continue
|
}
|
sdkVersion, ok := sm["version"]
|
if ok { //有版本号
|
vStr := sdkVersion.(string)
|
if shouldVersionBeUpgrade(vStr, skd.Def.Version) { //比对版本号确定是否需要安装
|
nInsM[skd.Def.SdkType] = skd.Def.SdkType
|
aInsM[skd.Def.Id] = skd.Def.Id
|
}
|
} else {
|
nInsM[skd.Def.SdkType] = skd.Def.SdkType
|
aInsM[skd.Def.Id] = skd.Def.Id
|
}
|
} else {
|
nInsM[skd.Def.SdkType] = skd.Def.SdkType
|
aInsM[skd.Def.Id] = skd.Def.Id
|
}
|
|
|
if _,ok := soM[skd.Def.SdkType];!ok {
|
soM[skd.Def.SdkType] = skd
|
}
|
if _,ok := aInsM[skd.Def.Id]; ok {
|
srv := SdkRegisterVo{}
|
srv.SdkCommon = skd.Def.SdkCommon
|
for _,ag := range skd.Args {
|
sra := SdkRegisterArgVo{
|
Scope: ag.Scope,
|
}
|
sra.SdkArg = 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)
|
}
|
paramBody := util.Struct2Map(srv)
|
logger.Debug("sdkApi.Register paramBody:", paramBody)
|
sdkApi.Register(paramBody) //将算法注册到数据库中
|
}
|
}
|
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 {
|
return false, cE
|
}
|
}
|
if util.DirExists(unPackPath+sdkType+"/models") {
|
if _,cE := util.CopyDirByCmd(unPackPath+sdkType+"/models", "./"); cE != nil {
|
return false, cE
|
}
|
//拷贝完成后删除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("反序列化算法定义信息失败")
|
return false, errors.New("错误的安装包")
|
}
|
} else {
|
logger.Debug("读取算法定义信息失败")
|
return false, errors.New("错误的安装包")
|
}
|
} else {
|
logger.Debug("算法定义信息丢失")
|
return false, errors.New("错误的安装包")
|
}
|
} else {
|
logger.Debug("反序列化授权信息失败")
|
return false, errors.New("错误的安装包")
|
}
|
} else {
|
logger.Debug("读取授权文件失败")
|
return false, errors.New("错误的安装包")
|
}
|
} else {
|
return false, errors.New("错误的安装包")
|
}
|
|
return true, nil
|
}
|
|
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"`
|
ProductId string `json:"productId"`
|
ActivateCode string `json:"activateCode"`
|
MachineCode string `json:"machineCode"`
|
UserId string `json:"userId"`
|
SdkIds []string `json:"sdkIds"`
|
ModuleIds []string `json:"moduleIds"`
|
ChCount int `json:"chCount"`
|
AuthCount int `json:"authCount"`
|
ServeYear int `json:"serveYear"`
|
|
ProductName string `json:"productName"`
|
InstallVersion string `json:"installVersion"`
|
InstallContent string `json:"installContent"`
|
}
|
|
//算法和参数定义
|
type SdkDef struct {
|
Def Sdk `json:"def"`
|
Args []SdkArgEntity `json:"args"`
|
}
|
|
type Sdk struct {
|
SdkCommon
|
CreateTime string `gorm:"column:create_time" json:"create_time"`
|
CreateBy string `gorm:"column:create_by" json:"create_by"`
|
UpdateTime string `gorm:"column:update_time" json:"update_time"`
|
Enable bool `gorm:"column:enable;default:1" json:"enable"`
|
DelFlag int `gorm:"column:del_flag;default:0" json:"del_flag"`
|
|
Args []SdkArg `json:"args"`
|
}
|
|
func (sc *SdkCommon) copyFromProto(pSdk protomsg.Sdk) {
|
sc.Id = pSdk.Id
|
sc.IpcId = pSdk.IpcId
|
sc.SdkType = pSdk.SdkType
|
sc.SdkName = pSdk.SdkName
|
sc.Icon = pSdk.Icon
|
sc.Url = pSdk.Url
|
sc.IconBlob = pSdk.IconBlob
|
sc.Version = pSdk.Version
|
sc.ArgDef = pSdk.ArgDef
|
sc.RuleSo = pSdk.RuleSo
|
}
|
|
type SdkCommon struct {
|
Id string `json:"id"`
|
IpcId string `json:"ipc_id"`
|
SdkType string `json:"sdk_type"`//人脸检测：FaceDetect,人脸提取：FaceExtract,人脸比对：FaceCompare,行为：Yolo
|
SdkName string `json:"sdk_name"` //算法名称
|
Icon string `json:"icon"` //算法图标
|
Url string `json:"url"` //算法下载地址
|
IconBlob string `json:"iconBlob"` //图片
|
Version string `json:"version"` //版本号
|
EnTrack bool `json:"enTrack"` //是否开启跟踪
|
ArgDef string `json:"argDef"` //算法默认参数定义
|
RuleSo string `json:"rule_so"`
|
}
|
|
type SdkInsOrUpgrade struct {
|
Sdk
|
RemoteVersion string `json:"remoteVersion"` //商城仓库版本号
|
Installed bool `json:"installed"` //是否已安装
|
IsUpgrade bool `json:"isUpgrade"` //是否需要升级
|
}
|
|
type SdkArgEntity struct {
|
Id string `gorm:"primary_key;column:id" json:"id"`
|
SdkId string `gorm:"column:sdk_id" json:"sdk_id"`
|
Scope string `gorm:"column:scope" json:"scope"`
|
SdkArg
|
}
|
|
type SdkArg struct {
|
Alias string `gorm:"column:alias" json:"alias"` //参数的别名
|
Name string `gorm:"column:name" json:"name"` //参数名称
|
Type string `gorm:"column:type" json:"type"` //参数类型(整数，字符串或数组)
|
ArgType string `gorm:"column:arg_type" json:"arg_type"`
|
Must bool `gorm:"column:must" json:"must"` //是否必填
|
Unit string `gorm:"column:unit" json:"unit"` //单位
|
Range string `gorm:"column:range" json:"range"` //值的范围，eg：0,100表示从0到100
|
DefaultValue string `gorm:"column:default_value" json:"default_value"`
|
DefaultOperator string `gorm:"column:default_operator" json:"default_operator"`
|
Sort int `gorm:"column:sort;default:1" json:"sort"`
|
}
|
|
|
type SdkRegisterVo struct {
|
SdkCommon
|
Args []SdkRegisterArgVo `json:"args"` //算法参数
|
}
|
|
type SdkRegisterArgVo struct {
|
Scope string `json:"scope"`
|
SdkArg
|
|
Dics []SdkArgDic `json:"dics"` //如果此算法参数是被选项，需要将参数枚举值写入到字典表中
|
}
|
|
type SdkArgDic struct {
|
Value string `json:"value"`
|
Name string `json:"name"`
|
Sort int `json:"sort"`
|
}
|
