692 lines
22 KiB
Go
692 lines
22 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"io/ioutil"
|
||
"os"
|
||
"regexp"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"go-common/app/admin/ep/melloi/conf"
|
||
"go-common/app/admin/ep/melloi/model"
|
||
"go-common/library/log"
|
||
)
|
||
|
||
//DoPtest do post
|
||
func (s *Service) DoPtest(c context.Context, ptestParam model.DoPtestParam) (resp model.DoPtestResp, err error) {
|
||
var (
|
||
testNameNick string
|
||
testNameNicks []string
|
||
)
|
||
if ptestParam.TestNameNick == "" {
|
||
tim := strconv.FormatInt(time.Now().Unix(), 10)
|
||
for _, testName := range ptestParam.TestNames {
|
||
testNameNick = testName + tim
|
||
testNameNicks = append(testNameNicks, testNameNick)
|
||
}
|
||
}
|
||
return s.DoPtestByJmeter(c, ptestParam, testNameNicks)
|
||
}
|
||
|
||
//StopPtest stop test
|
||
func (s *Service) StopPtest(c context.Context, ptestJob model.PtestJob) (err error) {
|
||
var (
|
||
jobNames []string
|
||
ptestJobs []*model.PtestJob
|
||
)
|
||
ptestJob.Active = 1
|
||
if ptestJobs, err = s.dao.QueryPtestJob(&ptestJob); err != nil {
|
||
log.Error("s.dao.QueryPtestJob err :(%v)", err)
|
||
return
|
||
}
|
||
for _, ptestJob := range ptestJobs {
|
||
jobNames = append(jobNames, ptestJob.JobName)
|
||
}
|
||
for _, jobName := range jobNames {
|
||
s.DeleteJob(context.TODO(), jobName)
|
||
}
|
||
return
|
||
}
|
||
|
||
//ReducePtest reduce ptest
|
||
func (s *Service) ReducePtest(c context.Context, reducePtest model.ReducePtest) (message string, err error) {
|
||
if reducePtest.JobName == "" {
|
||
message = "请输入 jobName"
|
||
return
|
||
}
|
||
if _, err = s.DeleteJob(c, reducePtest.JobName); err != nil {
|
||
message = "调用删除 job 接口失败"
|
||
log.Error("s.DeleteJob err :(%v)", err)
|
||
return
|
||
}
|
||
if err = s.dao.DeletePtestJob(reducePtest.ID); err != nil {
|
||
message = "sql 执行失败"
|
||
log.Error("s.dao.DeletePtestJob err :(%v)", err)
|
||
return
|
||
}
|
||
message = "success"
|
||
return
|
||
}
|
||
|
||
//QueryAllJobFree Query AllJob Free
|
||
func (s *Service) QueryAllJobFree(c context.Context, ptesJob *model.PtestJob) ([]*model.PtestJob, error) {
|
||
return s.dao.QueryPtestJob(ptesJob)
|
||
}
|
||
|
||
//QueryOrStopAllPtestByJobName query or stop all test by job name
|
||
func (s *Service) QueryOrStopAllPtestByJobName(c context.Context, reportSuID int, IsDelete bool, testStatus int) (ptestjobsd []*model.PtestJob, err error) {
|
||
|
||
// 删除所有正在允许此接口的容器
|
||
ptestJobd := model.PtestJob{ReportSuID: reportSuID, Active: 1}
|
||
if ptestjobsd, err = s.dao.QueryPtestJob(&ptestJobd); err != nil {
|
||
log.Error("s.dao.QueryPtestJob err (%v)", err)
|
||
return
|
||
}
|
||
|
||
if IsDelete {
|
||
for _, ptestJob := range ptestjobsd {
|
||
if _, err = s.DeleteJob(context.TODO(), ptestJob.JobName); err != nil {
|
||
log.Error("s.DeleteJob err :(%v)", err)
|
||
return
|
||
}
|
||
if err = s.dao.DeletePtestJob(ptestJob.ID); err != nil {
|
||
log.Error("s.dao.DeletePtestJob err (%v)", err)
|
||
return
|
||
}
|
||
if err = s.dao.UpdateReportStatusByID(reportSuID, testStatus); err != nil {
|
||
log.Error("s.UpdateReportStatusByID err :(%v)", err)
|
||
return
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
//DoAddPtest doadd test stress
|
||
func (s *Service) DoAddPtest(c context.Context, ptestAdd model.PtestAdd) (status string, err error) {
|
||
status = "fail"
|
||
var (
|
||
resp model.DoPtestResp
|
||
grpc *model.GRPC
|
||
scripts []*model.Script
|
||
resportSumm []*model.ReportSummary
|
||
)
|
||
ptestParam := model.DoPtestParam{}
|
||
// 此处 ScriptType 取自 reportSummary , 0-http 1-grpc 2-scene
|
||
if ptestAdd.ScriptType == model.PROTOCOL_GRPC {
|
||
if grpc, err = s.QueryGrpcById(ptestAdd.ScriptID); err != nil {
|
||
log.Error("Query GRPC err: (%v)", err)
|
||
return status, err
|
||
}
|
||
ptestParam = model.DoPtestParam{
|
||
UserName: grpc.UpdateBy, // 用户名
|
||
LoadTime: grpc.LoadTime, //运行时间
|
||
TestNames: StringToSlice(grpc.TaskName), //接口名转数组
|
||
FileName: grpc.JmxPath, // jmx文件
|
||
ResJtl: ptestAdd.ResJtl, // jtl时间戳
|
||
JmeterLog: ptestAdd.JmeterLog, // jmeterlog时间戳
|
||
Department: grpc.Department,
|
||
Project: grpc.Project,
|
||
IsDebug: false,
|
||
APP: grpc.APP,
|
||
ScriptID: grpc.ID,
|
||
Cookie: "", // 用不到
|
||
URL: grpc.ServiceName, // 用于微信通知
|
||
LabelIDs: nil,
|
||
Domain: grpc.HostName, // 微信通知Domain
|
||
FileSplit: false, // 文件切割
|
||
SplitNum: 0, // 切割数量
|
||
JarPath: grpc.JarPath,
|
||
Type: model.PROTOCOL_GRPC, //grpc
|
||
AddPtest: true, // 加压
|
||
}
|
||
}
|
||
if ptestAdd.ScriptType == model.PROTOCOL_SCENE {
|
||
ptestScene := model.DoPtestSceneParam{
|
||
SceneID: ptestAdd.SceneId,
|
||
UserName: ptestAdd.UserName,
|
||
}
|
||
if resp, err = s.DoScenePtest(c, ptestScene, true, ""); err != nil {
|
||
log.Error("s.DoScenePtest err :(%v)", err)
|
||
return status, err
|
||
}
|
||
}
|
||
if ptestAdd.ScriptType == model.PROTOCOL_HTTP {
|
||
script := model.Script{ID: ptestAdd.ScriptID}
|
||
if scripts, err = s.QueryScripts(&script, 1, 5); err != nil {
|
||
log.Error("QueryScripts err :(%v)", err)
|
||
return status, err
|
||
}
|
||
if len(scripts) > 0 {
|
||
// http 模板
|
||
ptestParam = model.DoPtestParam{
|
||
UserName: script.UpdateBy,
|
||
TestNames: QueryTestNamesByJmfile(scripts[0].SavePath),
|
||
FileName: scripts[0].SavePath,
|
||
LoadTime: 1800,
|
||
Upload: scripts[0].Upload,
|
||
ProjectName: scripts[0].ProjectName,
|
||
ResJtl: ptestAdd.ResJtl,
|
||
JmeterLog: ptestAdd.JmeterLog,
|
||
Department: scripts[0].Department,
|
||
Project: scripts[0].Project,
|
||
APP: scripts[0].App,
|
||
ScriptID: scripts[0].ID,
|
||
AddPtest: true,
|
||
Domain: scripts[0].Domain,
|
||
FileSplit: scripts[0].FileSplit,
|
||
SplitNum: scripts[0].SplitNum,
|
||
DockerSum: ptestAdd.DockerSum,
|
||
Type: model.PROTOCOL_HTTP,
|
||
APIHeader: scripts[0].APIHeader,
|
||
}
|
||
}
|
||
}
|
||
if ptestAdd.ScriptType != model.PROTOCOL_SCENE {
|
||
if resp, err = s.DoPtestByJmeter(c, ptestParam, nil); err != nil {
|
||
log.Error("DoPtestByJmeter err: (%v)", err)
|
||
return
|
||
}
|
||
log.Info("add ---jobName:(%s)", resp.JobName)
|
||
}
|
||
status = "success"
|
||
|
||
// 更新reportSummary数据表
|
||
reportSu := model.ReportSummary{ID: ptestAdd.ReportSuID}
|
||
if resportSumm, err = s.dao.QueryReportSurys(&reportSu); err != nil {
|
||
return
|
||
}
|
||
ptestJob := model.PtestJob{JobName: resp.JobName, ScriptID: ptestAdd.ScriptID, ReportSuID: ptestAdd.ReportSuID, Active: 1, ExecuteID: ptestAdd.ExecuteID, HostIP: resp.HostIP}
|
||
log.Info("add ---jobName:(%s)", resp.JobName)
|
||
if _, err = s.dao.AddPtestJob(&ptestJob); err != nil {
|
||
log.Error("s.dao.AddPtestJob err (%v)", err)
|
||
return
|
||
}
|
||
DockerSum := resportSumm[0].DockerSum + 1
|
||
if err = s.dao.UpdateReportDockByID(resportSumm[0].ID, DockerSum); err != nil {
|
||
log.Error("s.dao.UpdateReportDockByID err (%v)", err)
|
||
return
|
||
}
|
||
return
|
||
}
|
||
|
||
//AddPtest add ptest
|
||
func (s *Service) AddPtest(c context.Context, ptestAdd model.PtestAdd) (err error) {
|
||
go s.DoAddPtestWithSleep(c, ptestAdd)
|
||
return
|
||
}
|
||
|
||
//DoAddPtestWithSleep Do AddPtestWith Sleep
|
||
func (s *Service) DoAddPtestWithSleep(c context.Context, ptestAdd model.PtestAdd) (err error) {
|
||
var ptestJobs []*model.PtestJob
|
||
if ptestAdd.DockerNum == 0 {
|
||
ptestAdd.DockerNum = 1
|
||
}
|
||
if ptestAdd.SleepTime == 0 {
|
||
ptestAdd.SleepTime = 1
|
||
}
|
||
for i := 1; i <= ptestAdd.DockerNum; i++ {
|
||
time.Sleep(time.Duration(ptestAdd.SleepTime) * time.Second)
|
||
|
||
// 判断主容器状态，主容器被删除，则不再添加新的容器
|
||
ptestJob := model.PtestJob{JobName: ptestAdd.JobName}
|
||
if ptestJobs, err = s.dao.QueryPtestJob(&ptestJob); err != nil {
|
||
log.Error("s.dao.QueryPtestJob err :(%v)", err)
|
||
}
|
||
if len(ptestJobs) > 0 {
|
||
if ptestJobs[0].Active != -1 {
|
||
go s.DoAddPtest(context.TODO(), ptestAdd)
|
||
}
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
//DoPtestByFile do test by file
|
||
func (s *Service) DoPtestByFile(c context.Context, script model.Script, resJtl, jmeterLog string) (resp model.DoPtestResp, err error) {
|
||
var scripts []*model.Script
|
||
if scripts, err = s.QueryScripts(&script, 1, 5); err != nil {
|
||
log.Error("QueryScripts err :(%v)", err)
|
||
return
|
||
}
|
||
scriptID := scripts[0].ID
|
||
testNames := QueryTestNamesByJmfile(scripts[0].SavePath)
|
||
ptestParam := model.DoPtestParam{
|
||
UserName: script.UpdateBy,
|
||
TestNames: testNames,
|
||
FileName: scripts[0].SavePath,
|
||
LoadTime: 1800,
|
||
Upload: scripts[0].Upload,
|
||
ProjectName: scripts[0].ProjectName,
|
||
ResJtl: resJtl,
|
||
JmeterLog: jmeterLog,
|
||
Department: scripts[0].Department,
|
||
Project: scripts[0].Project,
|
||
APP: scripts[0].App,
|
||
ScriptID: scripts[0].ID,
|
||
Fusing: scripts[0].Fusing,
|
||
UseBusinessStop: scripts[0].UseBusinessStop,
|
||
BusinessStopPercent: scripts[0].BusinessStopPercent,
|
||
}
|
||
if resp, err = s.DoPtest(context.TODO(), ptestParam); err != nil {
|
||
log.Error("DoPtest error :(%v)", err)
|
||
return
|
||
}
|
||
resp.ScriptID = scriptID
|
||
return
|
||
}
|
||
|
||
//DoPtestArr QueryScriptsInID
|
||
func (s *Service) DoPtestArr(c context.Context, PtestBatch model.PtestBatch, cookie string) (status string, err error) {
|
||
var scripts []*model.Script
|
||
if scripts, err = s.dao.QueryScriptsInID(PtestBatch.IDArr); err != nil {
|
||
status = "fail"
|
||
log.Error("QueryScriptsInID err --- :(%v) ", err)
|
||
return status, err
|
||
}
|
||
|
||
for _, script := range scripts {
|
||
JmeterLog := script.JmeterLog + strconv.FormatInt(time.Now().Unix(), 10)
|
||
ResJtl := script.ResJtl + strconv.FormatInt(time.Now().Unix(), 10)
|
||
|
||
ptestParam := model.DoPtestParam{
|
||
UserName: PtestBatch.UserName,
|
||
FileName: script.SavePath,
|
||
ProjectName: script.ProjectName,
|
||
Upload: script.Upload,
|
||
ResJtl: ResJtl,
|
||
JmeterLog: JmeterLog,
|
||
Department: script.Department,
|
||
Project: script.Project,
|
||
APP: script.App,
|
||
ScriptID: script.ID,
|
||
URL: script.URL,
|
||
Cookie: cookie,
|
||
Domain: script.Domain,
|
||
FileSplit: script.FileSplit,
|
||
SplitNum: script.SplitNum,
|
||
Fusing: script.Fusing,
|
||
APIHeader: script.APIHeader,
|
||
}
|
||
if script.Upload {
|
||
ptestParam.LoadTime = 1800
|
||
ptestParam.TestNames = QueryTestNamesByJmfile(script.SavePath)
|
||
} else {
|
||
ptestParam.LoadTime = script.LoadTime
|
||
ptestParam.TestNames = StringToSlice(script.TestName)
|
||
}
|
||
go s.DoPtest(context.TODO(), ptestParam)
|
||
}
|
||
status = "success"
|
||
return
|
||
}
|
||
|
||
//DoPtestByScriptId do ptest by scriptid
|
||
func (s *Service) DoPtestByScriptId(c context.Context, script *model.Script, cookie, executor string) (resp model.DoPtestResp, err error) {
|
||
var scripts []*model.Script
|
||
if scripts, err = s.QueryScripts(script, 1, 5); err != nil {
|
||
log.Error("QueryScripts err :(%v)", err)
|
||
return
|
||
}
|
||
ptestParam := model.DoPtestParam{
|
||
TestNames: StringToSlice(scripts[0].TestName),
|
||
ProjectName: scripts[0].ProjectName,
|
||
FileName: scripts[0].SavePath,
|
||
LoadTime: scripts[0].LoadTime,
|
||
ResJtl: scripts[0].ResJtl,
|
||
JmeterLog: scripts[0].JmeterLog,
|
||
UserName: executor,
|
||
Department: scripts[0].Department,
|
||
Project: scripts[0].Project,
|
||
APP: scripts[0].App,
|
||
ScriptID: scripts[0].ID,
|
||
URL: scripts[0].URL,
|
||
Cookie: cookie,
|
||
Domain: scripts[0].Domain,
|
||
FileSplit: scripts[0].FileSplit,
|
||
SplitNum: scripts[0].SplitNum,
|
||
Fusing: scripts[0].Fusing,
|
||
APIHeader: scripts[0].APIHeader,
|
||
Upload: scripts[0].Upload,
|
||
UseBusinessStop: scripts[0].UseBusinessStop,
|
||
BusinessStopPercent: scripts[0].BusinessStopPercent,
|
||
}
|
||
|
||
if ptestParam.Upload {
|
||
ptestParam.TestNames = QueryTestNamesByJmfile(scripts[0].SavePath)
|
||
}
|
||
return s.DoPtest(c, ptestParam)
|
||
}
|
||
|
||
//DoPtestByJmeter do ptest by jmeter
|
||
func (s *Service) DoPtestByJmeter(c context.Context, ptestParam model.DoPtestParam, testNameNicks []string) (resp model.DoPtestResp, err error) {
|
||
var (
|
||
du string
|
||
Debug int
|
||
CPUCore int
|
||
reportSuID int
|
||
scriptSnapIDs []int
|
||
beginTime string
|
||
token string
|
||
Index = 0
|
||
btm time.Time
|
||
dus time.Duration
|
||
tempRes *model.PaasJobQueryStatus
|
||
hostIP string
|
||
command string
|
||
)
|
||
lay := "2006-01-02 15:04:05"
|
||
executeID := strconv.FormatInt(time.Now().UTC().UnixNano(), 10)
|
||
if !ptestParam.AddPtest {
|
||
// 不加压，增加新的 log
|
||
ptestParam.ResJtl = fmt.Sprintf("%s%s", ptestParam.ResJtl, executeID)
|
||
ptestParam.JmeterLog = fmt.Sprintf("%s%s", ptestParam.JmeterLog, executeID)
|
||
}
|
||
jobNamed := executeID + "run"
|
||
jobName := string([]rune(jobNamed)[10:])
|
||
|
||
// add filesplit messages to env variables
|
||
if !ptestParam.AddPtest {
|
||
Index = 1
|
||
} else {
|
||
Index = ptestParam.DockerSum + 1
|
||
}
|
||
ptestParam.EnvInfo = "FileSplit:" + strconv.FormatBool(ptestParam.FileSplit) + ",SplitNum:" + strconv.Itoa(ptestParam.SplitNum) +
|
||
",Index:" + strconv.Itoa(Index)
|
||
|
||
// 为压测容器绑定host
|
||
if ptestParam.Upload {
|
||
HostInfoByUploadSc(ptestParam.Domain)
|
||
} else {
|
||
if ptestParam.Type == model.PROTOCOL_HTTP {
|
||
HostInfo(ptestParam.Domain, ptestParam.APIHeader)
|
||
} else if ptestParam.Type == model.PROTOCOL_SCENE {
|
||
HostInfoList(ptestParam.Scripts)
|
||
}
|
||
}
|
||
|
||
if _, _, err = CreateResJtlAndJmeterLog(ptestParam); err != nil {
|
||
log.Info("create resjtl or jmeterlog err :(%v)", err)
|
||
return
|
||
}
|
||
//获取 Debug,CPUCore,command
|
||
Debug, CPUCore, command = s.CreateCommand(ptestParam)
|
||
|
||
jobInfo := model.Job{FileName: ptestParam.FileName, CPU: CPUCore, Memory: 8096, Parallelism: 1, Name: jobName, ResJtl: ptestParam.ResJtl,
|
||
JmeterLog: ptestParam.JmeterLog, EnvInfo: ptestParam.EnvInfo, JarPath: ptestParam.JarPath, Command: command}
|
||
|
||
beginTime = time.Now().Format(lay)
|
||
if btm, err = time.Parse(lay, beginTime); err != nil {
|
||
return
|
||
}
|
||
resd := int(btm.Unix()) % 5
|
||
du = "-" + strconv.Itoa(resd) + "s"
|
||
if dus, err = time.ParseDuration(du); err != nil {
|
||
return
|
||
}
|
||
|
||
beginTime = btm.Add(dus).Format(lay)
|
||
res := make(chan interface{}, 10000)
|
||
resHostIp := make(chan interface{}, 10000)
|
||
tm := time.Now()
|
||
for i := 0; i <= ptestParam.LoadTime+10; i += 5 {
|
||
tm = tm.Add(time.Second * 5)
|
||
}
|
||
timeout := time.After(time.Until(tm))
|
||
log.Info("job set timeout util --- :(%s) ", time.Until(tm))
|
||
|
||
if ptestParam.ExecuDockerSum == 0 {
|
||
ptestParam.ExecuDockerSum = 1
|
||
}
|
||
if _, err = s.AddJob(context.TODO(), jobInfo); err != nil {
|
||
log.Error("add ptest job err:(%v)", err)
|
||
return
|
||
}
|
||
if token, err = s.RmToken(c); err != nil {
|
||
log.Error("get token err:(%v)", err)
|
||
return
|
||
}
|
||
//获取物理机ip
|
||
if tempRes, err = s.Job(c, jobName); err != nil {
|
||
hostIP = ""
|
||
}
|
||
if len(tempRes.Data.Pods) > 0 {
|
||
hostIP = tempRes.Data.Pods[0].HostIP
|
||
}
|
||
|
||
// 如果不是增加容器，生成一份快照
|
||
if !ptestParam.AddPtest {
|
||
if scriptSnapIDs, err = s.AddSnap(c, ptestParam, executeID, jobName, jobNamed); err != nil || len(scriptSnapIDs) == 0 {
|
||
s.DeleteJob(context.TODO(), jobName)
|
||
return
|
||
}
|
||
// 从页面上直接输入参数生成的单场景脚本，testNames 和 testNameNicks 长度都是 1，reportSummary 测试计划为空
|
||
if reportSuID, err = s.AddReSummaryByPtest(ptestParam, jobName, jobNamed, testNameNicks, scriptSnapIDs[0], Debug); err != nil {
|
||
log.Error("s.dao.AddReportSummary err :(%v)", err)
|
||
s.DeleteJob(context.TODO(), jobName)
|
||
return
|
||
}
|
||
//容器写入 ptest_job 表
|
||
ptestJob := model.PtestJob{ScriptID: ptestParam.ScriptID, ReportSuID: reportSuID, JobName: jobName, Active: 1, ExecuteID: jobNamed, HostIP: hostIP}
|
||
if _, err = s.dao.AddPtestJob(&ptestJob); err != nil {
|
||
log.Error("s.dao.AddPtestJob err :(%v)", err)
|
||
s.DeleteJob(context.TODO(), jobName)
|
||
return
|
||
}
|
||
//获取场景中每个接口的熔断成功率的值
|
||
fusingList := make([]int, len(ptestParam.Scripts))
|
||
useBusiStopList := make([]bool, len(ptestParam.Scripts))
|
||
busiStopPercentList := make([]int, len(ptestParam.Scripts))
|
||
for index, script := range ptestParam.Scripts {
|
||
fusingList[index] = script.Fusing
|
||
useBusiStopList[index] = script.UseBusinessStop
|
||
busiStopPercentList[index] = script.BusinessStopPercent
|
||
}
|
||
AddReGraphTimer := model.AddReGraphTimer{
|
||
ScriptID: ptestParam.ScriptID,
|
||
JobName: jobName,
|
||
BeginTime: beginTime,
|
||
Token: token,
|
||
TestNames: ptestParam.TestNames,
|
||
TestNameNicks: testNameNicks,
|
||
ReportSuID: reportSuID,
|
||
Fusing: ptestParam.Fusing,
|
||
FusingList: fusingList,
|
||
TestType: ptestParam.Type,
|
||
UseBusinessStop: ptestParam.UseBusinessStop,
|
||
BusinessStopPercent: ptestParam.BusinessStopPercent,
|
||
UseBusiStopList: useBusiStopList,
|
||
BusiStopPercentList: busiStopPercentList,
|
||
}
|
||
//场景脚本的逻辑，可能存在多个test_name
|
||
if ptestParam.Type == model.PROTOCOL_SCENE && ptestParam.TestNameNick != "" {
|
||
AddReGraphTimer.TestNameNicks = ptestParam.TestNameNicks
|
||
AddReGraphTimer.TestNames = ptestParam.TestNames
|
||
}
|
||
//数据同步job
|
||
log.Info("-------开始执行数据同步job,loadTime :(%v)", ptestParam.LoadTime)
|
||
go s.addReGraphTimer(context.TODO(), AddReGraphTimer, res, timeout)
|
||
|
||
//查询容器hostIp
|
||
go s.addPtestJobHostIp(context.TODO(), AddReGraphTimer, resHostIp, timeout)
|
||
//增加label
|
||
if len(ptestParam.LabelIDs) > 0 && !ptestParam.IsDebug {
|
||
for _, lableID := range ptestParam.LabelIDs {
|
||
lrl := model.LabelRelation{LabelID: int64(lableID), Type: model.ScriptType, TargetID: int64(ptestParam.ScriptID)}
|
||
s.AddLabelRelation(&lrl)
|
||
lrll := model.LabelRelation{LabelID: int64(lableID), Type: model.ReportType, TargetID: int64(reportSuID)}
|
||
s.AddLabelRelation(&lrll)
|
||
}
|
||
}
|
||
//如果不是debug ，且配置发生通知为true，则发送微信通知
|
||
if !ptestParam.IsDebug && conf.Conf.Wechat.SendMessage {
|
||
serviceName := ptestParam.Department + "." + ptestParam.Project + "." + ptestParam.APP
|
||
var userService map[string][]string
|
||
if userService, err = s.QueryDependServiceAdmins(c, serviceName, s.getSessionInCookie(ptestParam.Cookie)); err != nil {
|
||
log.Error("query depend service admin error(%v)", err)
|
||
return
|
||
}
|
||
// 发送群通知
|
||
content := AddWechatContent(ptestParam, reportSuID, jobName, userService)
|
||
go s.AddWechatSend(context.TODO(), ptestParam.Cookie, content)
|
||
|
||
// 发送依赖服务通知
|
||
for user := range userService {
|
||
toUser := StringToSlice(user)
|
||
content = AddWechatDependServiceContent(ptestParam, userService, reportSuID, user)
|
||
go s.dao.PushWechatMsgToPerson(context.TODO(), ptestParam.Cookie, toUser, content)
|
||
}
|
||
}
|
||
}
|
||
resp = model.DoPtestResp{BeginTime: beginTime, ReportSuID: reportSuID, JobName: jobName, ScriptSnapIDs: scriptSnapIDs,
|
||
JmeterLog: ptestParam.JmeterLog, JtlLog: ptestParam.ResJtl, JmxFile: ptestParam.FileName, LoadTime: ptestParam.LoadTime, HostIP: hostIP}
|
||
return
|
||
}
|
||
|
||
//QueryTestNameNick query test nick name
|
||
func QueryTestNameNick(TestName string, testNameNicks []string) (testNameNick string) {
|
||
for _, testNameNickd := range testNameNicks {
|
||
if strings.Contains(testNameNickd, TestName) {
|
||
testNameNick = testNameNickd
|
||
break
|
||
}
|
||
}
|
||
return testNameNick
|
||
}
|
||
|
||
//IsUniqObject check whether object is unique
|
||
func IsUniqObject(aa []string) (t bool) {
|
||
for _, a := range aa {
|
||
if a == aa[0] {
|
||
t = true
|
||
continue
|
||
}
|
||
|
||
if a != aa[0] {
|
||
t = false
|
||
break
|
||
}
|
||
}
|
||
return t
|
||
}
|
||
|
||
//StringToSlice convert string to string slice
|
||
func StringToSlice(str string) (strs []string) {
|
||
strs = append(strs, str)
|
||
return
|
||
}
|
||
|
||
//RemoveRepByMap 去除切片钟的重复元素
|
||
func RemoveRepByMap(slc []string) (result []string) {
|
||
tempMap := map[string]byte{} // 存放不重复主键
|
||
for _, e := range slc {
|
||
l := len(tempMap)
|
||
tempMap[e] = 0
|
||
if len(tempMap) != l { // 加入map后，map长度变化，则元素不重复
|
||
result = append(result, e)
|
||
}
|
||
}
|
||
return result
|
||
}
|
||
|
||
//SliceToString join slice elements to string
|
||
func SliceToString(strs []string, inter string) (result string) {
|
||
for _, str := range strs {
|
||
result = result + inter + str
|
||
}
|
||
return string([]rune(result)[1:])
|
||
}
|
||
|
||
//QueryTestNamesByJmfile query test names by jmeter file
|
||
func QueryTestNamesByJmfile(fileName string) (testNames []string) {
|
||
var (
|
||
buff []byte
|
||
err error
|
||
)
|
||
if buff, err = ioutil.ReadFile(fileName); err != nil {
|
||
log.Error("open script file failed! error %v", err)
|
||
return
|
||
}
|
||
reg := regexp.MustCompile("SampleGui\"(.*)\" enabled=\"true")
|
||
reg2 := regexp.MustCompile("testname=\"(.*)\" enabled=\"true")
|
||
results := reg.FindAllString(string(buff), -1)
|
||
for _, res := range results {
|
||
resd := reg2.FindString(res)
|
||
resdd := strings.Replace(resd, "\" enabled=\"true", "", -1)
|
||
resddd := strings.Replace(resdd, "testname=\"", "", -1)
|
||
testNames = append(testNames, resddd)
|
||
}
|
||
return
|
||
}
|
||
|
||
//ExistsInSlice check whether the string in the slice
|
||
func ExistsInSlice(str string, strs []string) bool {
|
||
for _, st := range strs {
|
||
if st == str {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
//PingDomain ping domain
|
||
func PingDomain(ptestParam model.DoPtestParam) (pingString string) {
|
||
var pingStrings []string
|
||
if ptestParam.Type == model.PROTOCOL_HTTP {
|
||
pingString = " ping -c 1 " + ptestParam.Domain + " |tee -a " + ptestParam.JmeterLog
|
||
} else if ptestParam.Type == model.PROTOCOL_SCENE {
|
||
for _, script := range ptestParam.Scripts {
|
||
pingStrings = append(pingStrings, " ping -c 1 "+script.Domain+" |tee -a "+ptestParam.JmeterLog)
|
||
}
|
||
pingString = SliceToString(pingStrings, "&")
|
||
}
|
||
return
|
||
}
|
||
|
||
//CreateResJtlAndJmeterLog Create ResJt lAnd JmeterLog
|
||
func CreateResJtlAndJmeterLog(ptestParam model.DoPtestParam) (ResJtlFile, JmeterLogFile *os.File, err error) {
|
||
if ptestParam.ResJtl != "" {
|
||
if ResJtlFile, err = os.Create(ptestParam.ResJtl); err != nil {
|
||
log.Error("create ResJtl error :(%v)", err)
|
||
return
|
||
}
|
||
ResJtlFile.WriteString("此处显示 err 日志")
|
||
defer ResJtlFile.Close()
|
||
}
|
||
if ptestParam.JmeterLog != "" {
|
||
if JmeterLogFile, err = os.Create(ptestParam.JmeterLog); err != nil {
|
||
log.Error("create JmeterLog error :(%v)", err)
|
||
return
|
||
}
|
||
JmeterLogFile.WriteString("此处显示启动日志，执行debug 则显示debug 日志")
|
||
defer JmeterLogFile.Close()
|
||
}
|
||
return
|
||
}
|
||
|
||
//CreateCommand Create Command
|
||
func (s *Service) CreateCommand(ptestParam model.DoPtestParam) (debug, CPUCore int, command string) {
|
||
// ping 所有接口的 domain
|
||
pingString := PingDomain(ptestParam)
|
||
|
||
cpJar := ""
|
||
if ptestParam.JarPath != "" {
|
||
cpJar = fmt.Sprintf("cp %s %s & ", ptestParam.JarPath, s.c.Jmeter.JmeterExtLibPathContainer)
|
||
}
|
||
|
||
// 调试逻辑
|
||
if ptestParam.IsDebug {
|
||
CPUCore = s.c.Paas.CPUCoreDebug
|
||
debug = 1
|
||
command = cpJar + " mkdir /data/jmeter-log & jmeter -n -t " + ptestParam.FileName + " -j " + ptestParam.JmeterLog + " -l " + ptestParam.ResJtl + " -F ;" + pingString
|
||
} else {
|
||
CPUCore = s.c.Paas.CPUCore
|
||
debug = -1
|
||
command = cpJar + " mkdir /data/jmeter-log & jmeter -n -t " + ptestParam.FileName + " -j " + ptestParam.JmeterLog + " -l " + ptestParam.ResJtl + " -F"
|
||
}
|
||
return
|
||
}
|