Create & Init Project...

app/admin/ep/melloi/http/BUILD

@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "apply.go",
+        "clientmoni.go",
+        "cluster.go",
+        "comment.go",
+        "file.go",
+        "grpc.go",
+        "http.go",
+        "job.go",
+        "label.go",
+        "order.go",
+        "order_admin.go",
+        "ptest.go",
+        "rank.go",
+        "report.go",
+        "scene.go",
+        "script.go",
+        "tree.go",
+        "user.go",
+    ],
+    importpath = "go-common/app/admin/ep/melloi/http",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//app/admin/ep/melloi/conf:go_default_library",
+        "//app/admin/ep/melloi/model:go_default_library",
+        "//app/admin/ep/melloi/service:go_default_library",
+        "//library/ecode:go_default_library",
+        "//library/log:go_default_library",
+        "//library/net/http/blademaster:go_default_library",
+        "//library/net/http/blademaster/binding:go_default_library",
+        "//library/net/http/blademaster/middleware/permit:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/admin/ep/melloi/http/apply.go

@@ -0,0 +1,52 @@
+package http
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func queryApply(c *bm.Context) {
+	qar := model.QueryApplyRequest{}
+	if err := c.BindWith(&qar, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if err := qar.Verify(); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryApply(&qar))
+}
+
+func addApply(c *bm.Context) {
+	apply := model.Apply{}
+	if err := c.BindWith(&apply, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	cookie := c.Request.Header.Get("Cookie")
+	c.JSON(nil, srv.AddApply(c, cookie, &apply))
+}
+
+func updateApply(c *bm.Context) {
+	apply := model.Apply{}
+	if err := c.BindWith(&apply, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	cookie := c.Request.Header.Get("Cookie")
+	c.JSON(nil, srv.UpdateApply(cookie, &apply))
+}
+
+func delApply(c *bm.Context) {
+	v := new(struct {
+		ID int64 `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, srv.DeleteApply(v.ID))
+}

app/admin/ep/melloi/http/clientmoni.go

@@ -0,0 +1,27 @@
+package http
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func queryClientMoni(c *bm.Context) {
+
+	var (
+		cli    model.ClientMoni
+		resMap = make(map[string]interface{})
+	)
+	if err := c.BindWith(&cli, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	clientMonis, err := srv.QueryClientMoni(&cli)
+	if err != nil {
+		log.Error("srv.QueryClientMoni err (%v)", err)
+		return
+	}
+	resMap["clientMonis"] = clientMonis
+	c.JSON(resMap, err)
+}

app/admin/ep/melloi/http/cluster.go

@@ -0,0 +1,10 @@
+package http
+
+import (
+	bm "go-common/library/net/http/blademaster"
+)
+
+//ClusterInfo get cluster infomation
+func ClusterInfo(c *bm.Context) {
+	c.JSON(srv.ClusterInfo(c))
+}

app/admin/ep/melloi/http/comment.go

@@ -0,0 +1,46 @@
+package http
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func queryComment(c *bm.Context) {
+	comment := model.Comment{}
+	if err := c.BindWith(&comment, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryComment(&comment))
+}
+
+func addComment(c *bm.Context) {
+	comment := model.Comment{}
+	if err := c.BindWith(&comment, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.AddComment(&comment))
+}
+
+func updateComment(c *bm.Context) {
+	comment := model.Comment{}
+	if err := c.BindWith(&comment, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.UpdateComment(&comment))
+}
+
+func deleteComment(c *bm.Context) {
+	v := new(struct {
+		ID int64 `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, srv.DeleteComment(v.ID))
+}

app/admin/ep/melloi/http/file.go

@@ -0,0 +1,118 @@
+package http
+
+import (
+	"bytes"
+	"io"
+	"mime/multipart"
+	"path"
+	"strconv"
+	"time"
+
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+const (
+	_upLoadSuccess = "上传成功"
+	_upLoadFail    = "上传失败"
+)
+
+func upload(c *bm.Context) {
+	uploadParam := model.UploadParam{}
+	if err := c.BindWith(&uploadParam, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+
+	formFile, header, err := c.Request.FormFile("file")
+	if err != nil {
+		log.Error("Get form file failed,error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	var upLoadResultMap = make(map[string]string)
+	upLoadResultMap["result"] = _upLoadSuccess
+	scriptID, scriptPath, err := srv.Upload(c, &uploadParam, formFile, header)
+	if err != nil {
+		log.Error("Write file failed, error(%v)", err)
+		upLoadResultMap["result"] = _upLoadFail
+		c.JSON(upLoadResultMap, err)
+		return
+	}
+	upLoadResultMap["script_id"] = strconv.Itoa(scriptID)
+	upLoadResultMap["script_path"] = scriptPath
+	upLoadResultMap["full_path"] = path.Join(scriptPath, header.Filename)
+	c.JSON(upLoadResultMap, nil)
+}
+
+func uploadDependProto(c *bm.Context) {
+	var (
+		upParam  = &model.UploadParam{}
+		header   *multipart.FileHeader
+		formFile multipart.File
+		err      error
+	)
+
+	if err = c.BindWith(upParam, binding.Form); err != nil {
+		return
+	}
+	if formFile, header, err = c.Request.FormFile("file"); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.UploadAndGetProtoInfo(c, upParam, formFile, header))
+}
+
+func compileProtoFile(c *bm.Context) {
+	uploadParam := model.UploadParam{}
+	if err := c.BindWith(&uploadParam, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	fileName := strconv.FormatInt(time.Now().UTC().UnixNano(), 10)
+	c.JSON(srv.CompileProtoFile(uploadParam.ScriptPath, fileName))
+}
+
+func uploadImg(c *bm.Context) {
+	file, header, err := c.Request.FormFile("file")
+	if err != nil {
+		log.Error("get IMG file error (%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	defer file.Close()
+	buff := new(bytes.Buffer)
+	if _, err = io.Copy(buff, file); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(srv.UploadImg(c, buff.Bytes(), header.Filename))
+}
+
+func readFile(c *bm.Context) {
+	file := c.Request.Form.Get("file")
+	limit := c.Request.Form.Get("limit")
+	var upLoadResultMap = make(map[string]string)
+	data, err := srv.ReadFile(c, file, limit)
+	if err != nil {
+		return
+	}
+	upLoadResultMap["data"] = data
+	c.JSON(upLoadResultMap, nil)
+}
+
+func downloadFile(c *bm.Context) {
+	filePath := c.Request.Form.Get("file_path")
+	c.JSON(nil, srv.DownloadFile(c, filePath, c.Writer))
+}
+
+func isFileExists(c *bm.Context) {
+	fileName := c.Request.Form.Get("file_name")
+	exists, err := srv.IsFileExists(c, fileName)
+	var ResultMap = make(map[string]string)
+	ResultMap["fileExists"] = strconv.FormatBool(exists)
+	c.JSON(ResultMap, err)
+}

app/admin/ep/melloi/http/grpc.go

@@ -0,0 +1,209 @@
+package http
+
+import (
+	"net/http"
+	"path/filepath"
+
+	"go-common/app/admin/ep/melloi/model"
+
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func getProto(c *bm.Context) {
+	v := new(struct {
+		Path string `form:"path"`
+	})
+	if err := c.Bind(v); err != nil {
+		return
+	}
+
+	path, fileName := filepath.Split(v.Path)
+	var (
+		res = make(map[string]interface{})
+		err error
+	)
+	if res, err = srv.ProtoParsing(path, fileName); err != nil {
+		log.Error("parser grpc error(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+
+	if err = srv.CreateGRPCImportDir(res, path); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(res, err)
+}
+
+func createDependencyPath(c *bm.Context) {
+	protoPath := &model.ProtoPathModel{}
+
+	if err := c.BindWith(protoPath, binding.JSON); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, srv.CreateProtoImportDir(protoPath))
+}
+
+func grpcQuickStart(c *bm.Context) {
+	var (
+		userName *http.Cookie
+		qsReq    = &model.GRPCQuickStartRequest{}
+		err      error
+		cookie   string
+	)
+
+	cookie = c.Request.Header.Get("Cookie")
+	if err = c.BindWith(qsReq, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if userName, err = c.Request.Cookie("username"); err != nil {
+		c.JSON(nil, ecode.AccessKeyErr)
+		return
+	}
+	c.JSON(srv.GRPCQuickStart(c, qsReq, userName.Value, cookie))
+}
+
+func saveGrpc(c *bm.Context) {
+	var (
+		qsReq = &model.GRPCQuickStartRequest{}
+		err   error
+	)
+
+	if err = c.BindWith(qsReq, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+
+	c.JSON(nil, srv.SaveGRPCQuickStart(c, qsReq))
+}
+
+func runGrpc(c *bm.Context) {
+	var (
+		grpc     = model.GRPC{}
+		err      error
+		userName *http.Cookie
+		cookie   string
+	)
+
+	cookie = c.Request.Header.Get("Cookie")
+	if err = c.BindWith(&grpc, binding.JSON); nil != err {
+		c.JSON(nil, err)
+		return
+	}
+	if userName, err = c.Request.Cookie("username"); err != nil {
+		c.JSON(nil, ecode.AccessKeyErr)
+		return
+	}
+	c.JSON(srv.GRPCRunByModel(c, &grpc, userName.Value, cookie))
+}
+
+func runGrpcByScriptId(c *bm.Context) {
+	var (
+		userName   *http.Cookie
+		err        error
+		grpcExeReq = &model.GRPCExecuteScriptRequest{}
+		cookie     string
+	)
+
+	cookie = c.Request.Header.Get("Cookie")
+	if err = c.BindWith(grpcExeReq, binding.JSON); err != nil {
+		return
+	}
+	if userName, err = c.Request.Cookie("username"); err != nil {
+		c.JSON(nil, ecode.AccessKeyErr)
+		return
+	}
+	c.JSON(srv.GRPCRunByScriptID(c, grpcExeReq, userName.Value, cookie))
+}
+
+func grpcAddScript(c *bm.Context) {
+	grpcReq := model.GRPCAddScriptRequest{}
+	if err := c.BindWith(&grpcReq, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.GRPCAddScript(c, &grpcReq))
+}
+
+func queryGrpc(c *bm.Context) {
+	qgr := model.QueryGRPCRequest{}
+
+	if err := c.BindWith(&qgr, binding.Form); err != nil {
+		c.JSON(nil, err)
+	}
+	if err := qgr.Verify(); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	sessionID, err := c.Request.Cookie("_AJSESSIONID")
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryGrpc(c, sessionID.Value, &qgr))
+}
+
+func deleteGrpc(c *bm.Context) {
+	v := new(struct {
+		ID int `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, srv.DeleteGrpc(v.ID))
+}
+
+func updateGrpc(c *bm.Context) {
+	grpc := model.GRPC{}
+	if err := c.BindWith(&grpc, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+
+	qgr := &model.GRPCAddScriptRequest{}
+	qgr.ThreadsSum = grpc.ThreadsSum
+	qgr.RampUp = grpc.RampUp
+	qgr.Loops = grpc.Loops
+	qgr.LoadTime = grpc.LoadTime
+	qgr.HostName = grpc.HostName
+	qgr.Port = grpc.Port
+	qgr.ServiceName = grpc.ServiceName
+	qgr.ProtoClassName = grpc.ProtoClassName
+	qgr.PkgPath = grpc.PkgPath
+	qgr.RequestType = grpc.RequestType
+	qgr.ResponseType = grpc.ResponseType
+	qgr.ScriptPath = grpc.ScriptPath
+	qgr.RequestMethod = grpc.RequestMethod
+	qgr.RequestContent = grpc.RequestContent
+	qgr.TaskName = grpc.TaskName
+	qgr.ParamFilePath = grpc.ParamFilePath
+	qgr.ParamNames = grpc.ParamNames
+	qgr.ParamDelimiter = grpc.ParamDelimiter
+	g, err := srv.CreateJmx(c, qgr)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	grpc.JmxPath = g.JmxPath
+	grpc.JtlLog = g.JtlLog
+	grpc.JmxLog = g.JmxLog
+
+	c.JSON(nil, srv.UpdateGrpc(&grpc))
+}
+
+func queryGrpcSnap(c *bm.Context) {
+	v := new(struct {
+		ID int `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(srv.QueryGRPCSnapByID(v.ID))
+}

app/admin/ep/melloi/http/http.go

@@ -0,0 +1,235 @@
+package http
+
+import (
+	"net/http"
+
+	"go-common/app/admin/ep/melloi/conf"
+	"go-common/app/admin/ep/melloi/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/middleware/permit"
+)
+
+var (
+	srv *service.Service
+	// AuthSrv Auth Service
+	AuthSrv *permit.Permit
+)
+
+// Init init
+func Init(c *conf.Config, s *service.Service) {
+	srv = s
+	AuthSrv = permit.New2(c.PermitGRPC)
+	engine := bm.NewServer(c.BM)
+	engine.Ping(ping)
+	router(engine)
+	if err := engine.Start(); err != nil {
+		log.Error("xhttp.Serve2 error(%v)", err)
+		panic(err)
+	}
+}
+
+// router init outer router api path
+func router(e *bm.Engine) {
+	e.Register(register)
+	version := e.Group("/ep/admin/melloi/v1", AuthSrv.Permit2(""))
+	{
+		home := version.Group("/rank")
+		{
+			home.GET("/trees/query", treesQuery)
+			home.GET("/top/http/query", topHttpQuery)
+			home.GET("/top/dept/query", topDeptQuery)
+			home.GET("/treenum/query", treeNumQuery)
+			home.GET("/buildline/query", buildLineQuery)
+			home.GET("/stateline/query", stateLineQuery)
+			home.GET("/top/grpc/query", topGrpcQuery)
+			home.GET("/top/scene/query", topSceneQuery)
+		}
+		user := version.Group("/user")
+		{
+			user.GET("/query", queryUser)
+			user.POST("/update", updateUser)
+		}
+		//手工压测
+		order := version.Group("/order")
+		{
+			order.GET("/query", queryOrder)
+			order.POST("/add", addOrder)
+			order.POST("/update", updateOrder)
+			order.GET("/del", delOrder)
+			order.POST("/report/add", addOrderReport)
+			order.GET("/report/query", queryOrderReport)
+		}
+		//非压测时间段压测申请
+		apply := version.Group("/apply")
+		{
+			apply.GET("/query", queryApply)
+			apply.POST("/add", addApply)
+			apply.POST("/update", updateApply)
+			apply.GET("/del", delApply)
+		}
+		orderAdmin := version.Group("/admin")
+		{
+			orderAdmin.GET("/query", queryOrderAdmin)
+			orderAdmin.GET("/add", addOrderAdmin)
+		}
+		script := version.Group("/script")
+		{
+			script.POST("/gettgroup", getThreadGroup)
+			script.POST("/add", addAndExecuteScript)
+			script.POST("/grpc/add", grpcAddScript)
+			script.POST("/update", updateScript)
+			script.POST("/updateall", updateScriptAll)
+			script.GET("/delete", delScript)
+			script.GET("/query", queryScripts)
+			script.GET("/query/free", queryScripysFree)
+			script.GET("/querysnap", queryScriptSnap)
+			script.POST("/url/check", urlCheck)
+			script.POST("/addtimer", addTimer)
+		}
+
+		scene := version.Group("/scene")
+		{
+			scene.POST("/addscene/auto", AddAndExecuScene)
+			scene.GET("/draft/query", queryDraft)
+			scene.POST("/update", updateScene)
+			scene.POST("/add", addScene)
+			scene.POST("/save", saveScene)
+			scene.POST("/saveorder", saveOrder)
+			scene.GET("/relation/query", queryRelation)
+			scene.GET("/api/query", queryAPI)
+			scene.POST("/api/delete", deleteAPI)
+			scene.POST("/group/config/add", addConfig)
+			scene.GET("/tree/query", queryTree)
+			scene.GET("/query", queryScenes)
+			scene.POST("/doptest", doScenePtest)
+			scene.POST("/doptest/batch", doScenePtestBatch)
+			scene.GET("/existapi/query", queryExistAPI)
+			scene.GET("/preview/query", queryPreview)
+			scene.GET("/params/query", queryParams)
+			scene.POST("/bindScene/update", updateBindScene)
+			scene.GET("/drawrelation/query", queryDrawRelation)
+			scene.POST("/script/add", addSceneScript)
+			scene.POST("/draft/delete", deleteDraft)
+			scene.GET("/group/config/query", queryConfig)
+			scene.GET("/delete", deleteScene)
+			scene.POST("/copy", copyScene)
+			scene.GET("/fusing/query", queryFusing)
+		}
+
+		run := version.Group("/run")
+		{
+			run.GET("/time/check", runTimeCheck)
+			run.POST("/grpc/run", runGrpc)
+			run.GET("/grpc/query", queryGrpc)
+			run.POST("/grpc/update", updateGrpc)
+			run.GET("/grpc/delete", deleteGrpc)
+			run.GET("/grpc/snap/query", queryGrpcSnap)
+			run.GET("/proto/query", getProto)
+		}
+
+		file := version.Group("/file")
+		{
+			file.POST("/upload", upload)
+			file.POST("/proto/refer/upload", uploadDependProto)
+			file.GET("/read", readFile)
+			file.GET("/download", downloadFile)
+			file.GET("/exists", isFileExists)
+			file.POST("/img", uploadImg)
+			file.POST("/proto/compile", compileProtoFile)
+		}
+		tree := version.Group("/tree")
+		{
+			tree.GET("/query", queryUserTree)
+			tree.GET("/admin", queryTreeAdmin)
+		}
+		report := version.Group("report")
+		{
+			report.POST("/update/summary", updateReportSummary)
+			report.GET("/query", queryReportSummarys)
+			report.POST("/query/regraph", queryReGraph)
+			report.POST("/query/regraphavg", queryReGraphAvg)
+			report.GET("/update/status", updateReportStatus)
+			report.GET("/del", delReport)
+			report.GET("/query/id", queryReportByID)
+		}
+		moni := version.Group("moni")
+		{
+			moni.GET("/client", queryClientMoni)
+		}
+
+		ptest := version.Group("ptest")
+		{
+			ptest.GET("/add", addPtest)
+			ptest.GET("/reduce", reducePtest)
+			ptest.GET("/queryalljob", queryAllJob)
+			ptest.GET("/queryalljob/free", queryAllJobFree)
+			ptest.GET("/stop", stopPtest)
+			ptest.GET("/stopall", stopAllPtest)
+			ptest.GET("/doptest", doPtest)
+			ptest.GET("/doptest/scriptid", doPtestByScriptId)
+			ptest.POST("/grpc/quickstart", grpcQuickStart)
+			ptest.POST("/grpc/qksave", saveGrpc)
+			ptest.POST("/grpc/run", runGrpcByScriptId)
+			ptest.POST("/grpc/createpath", createDependencyPath)
+			ptest.POST("/doptestfile", doPtestByFile)
+			ptest.POST("/dobatchptest", doPtestBatch)
+			ptest.POST("/dodebug", doDebug)
+		}
+		cluster := version.Group("/cluster")
+		{
+			cluster.GET("/info", ClusterInfo)
+			job := version.Group("/job")
+			{
+				job.POST("/add", addJob)
+				job.POST("/delete/batch", deleteJobBatch)
+				job.DELETE("/delete", deleteJob)
+				job.GET("/get", Job)
+				job.GET("/clean/query", queryClearnableDocker)
+				job.GET("/clean", cleanNotRunningJob)
+			}
+		}
+		comment := version.Group("/comment")
+		{
+			comment.GET("/query", queryComment)
+			comment.POST("/add", addComment)
+			comment.POST("/update", updateComment)
+			comment.GET("/delete", deleteComment)
+		}
+
+		label := version.Group("/label")
+		{
+			label.GET("/query", queryLabels)
+			label.POST("/add", addLabel)
+			label.GET("/del", delLabel)
+			label.POST("/relation/add", addLabelRelation)
+			label.GET("/relation/del", delLabelRelation)
+		}
+	}
+	versiond := e.Group("/ep/admin/melloi/v2")
+	{
+		script := versiond.Group("script")
+		{
+			script.POST("/addsample", addJmeterSample)
+			script.POST("/addtgroup", addThreadGroup)
+		}
+		file := versiond.Group("/file")
+		{
+			file.GET("/download", downloadFile)
+		}
+		job := versiond.Group("/job")
+		{
+			job.GET("/force/delete", forceDelete)
+		}
+	}
+}
+
+func register(c *bm.Context) {
+	c.JSON(map[string]interface{}{}, nil)
+}
+func ping(c *bm.Context) {
+	if err := srv.Ping(c); err != nil {
+		log.Error("ping error(%v)", err)
+		c.AbortWithStatus(http.StatusServiceUnavailable)
+	}
+}

app/admin/ep/melloi/http/job.go

@@ -0,0 +1,52 @@
+package http
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func addJob(c *bm.Context) {
+	job := model.Job{}
+	if err := c.BindWith(&job, binding.JSON); nil != err {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.AddJob(c, job))
+}
+func deleteJob(c *bm.Context) {
+	name := c.Request.Form.Get("name")
+	c.JSON(srv.DeleteJob(c, name))
+}
+
+func deleteJobBatch(c *bm.Context) {
+	JobBatch := model.JobBatch{}
+	if err := c.BindWith(&JobBatch, binding.JSON); nil != err {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.DeleteJobBatch(c, JobBatch), nil)
+}
+
+//Job get job info
+func Job(c *bm.Context) {
+	name := c.Request.Form.Get("name")
+	c.JSON(srv.Job(c, name))
+}
+
+func forceDelete(c *bm.Context) {
+	ptestJob := model.PtestJob{}
+	if err := c.BindWith(&ptestJob, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.ForceDeleteJob(c, ptestJob.ReportSuID))
+}
+
+func queryClearnableDocker(c *bm.Context) {
+	c.JSON(srv.QueryCleanableDocker(c))
+}
+
+func cleanNotRunningJob(c *bm.Context) {
+	c.JSON(nil, srv.CleanJob(c))
+}

app/admin/ep/melloi/http/label.go

@@ -0,0 +1,53 @@
+package http
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func queryLabels(c *bm.Context) {
+	c.JSON(srv.QueryLabel(c))
+}
+
+func addLabel(c *bm.Context) {
+	label := model.Label{}
+	if err := c.BindWith(&label, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.AddLabel(&label))
+}
+
+func delLabel(c *bm.Context) {
+	v := new(struct {
+		ID int64 `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, srv.DeleteLabel(v.ID))
+}
+
+func addLabelRelation(c *bm.Context) {
+	lr := model.LabelRelation{}
+	if err := c.BindWith(&lr, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.AddLabelRelation(&lr))
+}
+
+func delLabelRelation(c *bm.Context) {
+	v := new(struct {
+		ID int64 `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+
+	c.JSON(nil, srv.DeleteLabelRelation(v.ID))
+}

app/admin/ep/melloi/http/order.go

@@ -0,0 +1,77 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func queryOrder(c *bm.Context) {
+	qor := model.QueryOrderRequest{}
+	if err := c.BindWith(&qor, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if err := qor.Verify(); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryOrder(&qor))
+}
+
+func addOrder(c *bm.Context) {
+	order := model.Order{}
+	if err := c.BindWith(&order, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.AddOrder(&order))
+}
+
+func updateOrder(c *bm.Context) {
+	order := model.Order{}
+	if err := c.BindWith(&order, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.UpdateOrder(&order))
+}
+
+func delOrder(c *bm.Context) {
+	v := new(struct {
+		ID int64 `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, srv.DelOrder(v.ID))
+}
+
+func addOrderReport(c *bm.Context) {
+	report := new(model.OrderReport)
+	if err := c.BindWith(&report, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+
+	nameStr := ""
+	if username, err := c.Request.Cookie("username"); err == nil || username != nil {
+		nameStr = username.Value
+	}
+	c.JSON(nil, srv.AddReport(nameStr, report))
+}
+
+func queryOrderReport(c *bm.Context) {
+	params := c.Request.Form
+	orderID := params.Get("order_id")
+	oid, err := strconv.ParseInt(orderID, 10, 64)
+	if err != nil || oid <= 0 {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(srv.QueryReportByOrderID(oid))
+}

app/admin/ep/melloi/http/order_admin.go

@@ -0,0 +1,22 @@
+package http
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+// get administrator for order by current username
+func queryOrderAdmin(c *bm.Context) {
+	userName, _ := c.Request.Cookie("username")
+	c.JSON(srv.QueryOrderAdmin(userName.Value))
+}
+
+// add administrator for order
+func addOrderAdmin(c *bm.Context) {
+	admin := model.OrderAdmin{}
+	if err := c.BindWith(&admin, binding.Form); err != nil {
+		return
+	}
+	c.JSON(nil, srv.AddOrderAdmin(&admin))
+}

app/admin/ep/melloi/http/ptest.go

@@ -0,0 +1,243 @@
+package http
+
+import (
+	"encoding/json"
+
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/app/admin/ep/melloi/service"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+//excute performTest
+func doPtest(c *bm.Context) {
+	var (
+		script     model.Script
+		ptestParam model.DoPtestParam
+	)
+	userName := c.Request.Form.Get("userName")
+	param := c.Request.Form.Get("param")
+	resJtl := c.Request.Form.Get("resJtl")
+	jmeterLog := c.Request.Form.Get("jmeterLog")
+	cookie := c.Request.Header.Get("Cookie")
+	if err := json.Unmarshal([]byte(param), &script); err != nil {
+		log.Error("sorry,script err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	log.Info("接口名：(%s),压测脚本路径：(%s)", script.TestName, script.SavePath)
+	if script.Upload {
+		testNames := service.QueryTestNamesByJmfile(script.SavePath)
+		ptestParam = model.DoPtestParam{
+			TestNames:   testNames,
+			FileName:    script.SavePath,
+			LoadTime:    1800,
+			UserName:    userName,
+			Upload:      true,
+			ProjectName: script.ProjectName,
+			FileSplit:   script.FileSplit,
+			SplitNum:    script.SplitNum,
+			APIHeader:   script.APIHeader,
+		}
+	} else {
+		ptestParam = model.DoPtestParam{
+			TestNames: service.StringToSlice(script.TestName),
+			FileName:  script.SavePath,
+			LoadTime:  script.LoadTime,
+			UserName:  userName,
+			URL:       script.URL,
+			FileSplit: script.FileSplit,
+			SplitNum:  script.SplitNum,
+			APIHeader: script.APIHeader,
+		}
+	}
+	ptestParam.Department = script.Department
+	ptestParam.Project = script.Project
+	ptestParam.APP = script.App
+	ptestParam.Domain = script.Domain
+	ptestParam.Cookie = cookie
+	ptestParam.JmeterLog = jmeterLog
+	ptestParam.ResJtl = resJtl
+	ptestParam.ScriptID = script.ID
+	ptestParam.UseBusinessStop = script.UseBusinessStop
+	ptestParam.BusinessStopPercent = script.BusinessStopPercent
+	ptestParam.Fusing = script.Fusing
+	c.JSON(srv.DoPtest(c, ptestParam))
+}
+
+//addPtest  加压
+func addPtest(c *bm.Context) {
+	var ptestAdd model.PtestAdd
+	if err := c.BindWith(&ptestAdd, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	log.Info("AddPtest ----")
+	c.JSON(nil, srv.AddPtest(c, ptestAdd))
+}
+
+//stopPtest
+func stopPtest(c *bm.Context) {
+	var ptestJob model.PtestJob
+	if err := c.BindWith(&ptestJob, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.StopPtest(c, ptestJob))
+}
+
+//stopAllPtest
+func stopAllPtest(c *bm.Context) {
+	var allPtestStop model.AllPtestStop
+	if err := c.BindWith(&allPtestStop, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryOrStopAllPtestByJobName(c, allPtestStop.ReportSuID, true, 3))
+}
+
+//reducePtest
+func reducePtest(c *bm.Context) {
+	var (
+		reducePtest model.ReducePtest
+		resMap      = make(map[string]interface{})
+	)
+	if err := c.BindWith(&reducePtest, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	message, err := srv.ReducePtest(c, reducePtest)
+	if err != nil {
+		return
+	}
+	resMap["message"] = message
+	c.JSON(resMap, err)
+}
+
+//queryAllJob
+func queryAllJob(c *bm.Context) {
+	var (
+		ptestJob model.PtestJob
+		resMap   = make(map[string]interface{})
+	)
+	if err := c.BindWith(&ptestJob, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	ptestJobs, err := srv.QueryOrStopAllPtestByJobName(c, ptestJob.ReportSuID, false, 3)
+	if err != nil {
+		log.Error("query ptestJob err", err)
+		return
+	}
+	resMap["ptest_jobs"] = ptestJobs
+	c.JSON(resMap, err)
+}
+
+//queryAllJobFree queryAll JobFree
+func queryAllJobFree(c *bm.Context) {
+	var (
+		ptestJob model.PtestJob
+		resMap   = make(map[string]interface{})
+	)
+	if err := c.BindWith(&ptestJob, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	ptestJobs, err := srv.QueryAllJobFree(c, &ptestJob)
+	if err != nil {
+		log.Error("query ptestJob err", err)
+		return
+	}
+	resMap["ptest_jobs"] = ptestJobs
+	c.JSON(resMap, err)
+}
+
+//doDebug
+func doDebug(c *bm.Context) {
+	var script model.Script
+	var ptestParam model.DoPtestParam
+	param := c.Request.Form.Get("param")
+	userName := c.Request.Form.Get("userName")
+	if err := json.Unmarshal([]byte(param), &script); err != nil {
+		log.Error("sorry,script err(%v)", err)
+		c.JSON(nil, err)
+		return
+	}
+	log.Info("接口名：(%s),压测脚本路径：(%s)", script.TestName, script.SavePath)
+	if script.Upload {
+		ptestParam = model.DoPtestParam{
+			TestNames:   service.QueryTestNamesByJmfile(script.SavePath),
+			FileName:    script.SavePath,
+			LoadTime:    1800,
+			UserName:    userName,
+			Upload:      true,
+			ProjectName: script.ProjectName,
+			ResJtl:      script.ResJtl,
+			JmeterLog:   script.JmeterLog,
+			Department:  script.Department,
+			Project:     script.Project,
+			APP:         script.App,
+			ScriptID:    script.ID,
+		}
+	} else {
+		ptestParam = model.DoPtestParam{
+			TestNames:  service.StringToSlice(script.TestName),
+			FileName:   script.SavePath,
+			LoadTime:   script.LoadTime,
+			UserName:   userName,
+			ResJtl:     script.ResJtl,
+			JmeterLog:  script.JmeterLog,
+			Department: script.Department,
+			Project:    script.Project,
+			APP:        script.App,
+			ScriptID:   script.ID,
+			Domain:     script.Domain,
+		}
+	}
+	c.JSON(srv.DoPtest(c, ptestParam))
+}
+
+func doPtestByFile(c *bm.Context) {
+	var script model.Script
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	resJtl := script.ResJtl
+	jmeterLog := script.JmeterLog
+	script.ResJtl = ""
+	script.JmeterLog = ""
+	resp, err := srv.DoPtestByFile(c, script, resJtl, jmeterLog)
+	if err != nil {
+		c.JSON(err, nil)
+		return
+	}
+	c.JSON(resp, err)
+}
+
+//excute batch ptest
+func doPtestBatch(c *bm.Context) {
+	var PtestBatch model.PtestBatch
+	if err := c.BindWith(&PtestBatch, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	cookie := c.Request.Header.Get("Cookie")
+	status, _ := srv.DoPtestArr(c, PtestBatch, cookie)
+	var doPostMap = make(map[string]string)
+	doPostMap["status"] = status
+	c.JSON(doPostMap, nil)
+}
+
+//doPtestByScriptId
+func doPtestByScriptId(c *bm.Context) {
+	var script model.Script
+	if err := c.BindWith(&script, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	cookie := c.Request.Header.Get("Cookie")
+	executor := c.Request.Form.Get("executor")
+	c.JSON(srv.DoPtestByScriptId(c, &script, cookie, executor))
+}

app/admin/ep/melloi/http/rank.go

@@ -0,0 +1,49 @@
+package http
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func treesQuery(c *bm.Context) {
+	c.JSON(srv.TreesQuery())
+}
+
+func treeNumQuery(c *bm.Context) {
+	c.JSON(srv.TreeNumQuery())
+}
+
+func topHttpQuery(c *bm.Context) {
+	c.JSON(srv.TopHttpQuery())
+}
+
+func topGrpcQuery(c *bm.Context) {
+	c.JSON(srv.TopGrpcQuery())
+}
+
+func topSceneQuery(c *bm.Context) {
+	c.JSON(srv.TopSceneQuery())
+}
+
+func topDeptQuery(c *bm.Context) {
+	c.JSON(srv.TopDeptQuery())
+}
+
+func buildLineQuery(c *bm.Context) {
+	rank := model.Rank{}
+	summary := model.ReportSummary{}
+	if err := c.BindWith(&rank, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if err := c.BindWith(&summary, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.BuildLineQuery(&rank, &summary))
+}
+
+func stateLineQuery(c *bm.Context) {
+	c.JSON(srv.StateLineQuery())
+}

app/admin/ep/melloi/http/report.go

@@ -0,0 +1,106 @@
+package http
+
+import (
+	"strconv"
+
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func updateReportSummary(c *bm.Context) {
+	reportSummary := model.ReportSummary{}
+	if err := c.BindWith(&reportSummary, binding.JSON); nil != err {
+		c.JSON(nil, err)
+		return
+	}
+	var ResultMap = make(map[string]string)
+	status, err := srv.UpdateReportSummary(&reportSummary)
+	ResultMap["status"] = status
+	c.JSON(ResultMap, err)
+}
+
+func queryReportSummarys(c *bm.Context) {
+	qrsr := model.QueryReportSuRequest{}
+	if err := c.BindWith(&qrsr, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if err := qrsr.Verify(); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	sessionID, err := c.Request.Cookie("_AJSESSIONID")
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+
+	res, err := srv.QueryReportSummarys(c, sessionID.Value, &qrsr)
+	if err != nil {
+		log.Error("queryScripts Error", err)
+		return
+	}
+	c.JSON(res, err)
+}
+
+func queryReportByID(c *bm.Context) {
+	v := new(struct {
+		ID int `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(srv.QueryReportByID(v.ID))
+}
+
+func queryReGraph(c *bm.Context) {
+	reGraphParam := model.QueryReGraphParam{}
+	if err := c.BindWith(&reGraphParam, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	log.Info("TestNameNicks:(%s)", reGraphParam.TestNameNicks)
+	reportGraphs, err := srv.QueryReGraph(reGraphParam.TestNameNicks)
+	var resultGraphMap = make(map[string][][]model.ReportGraph)
+	resultGraphMap["reportGraphs"] = reportGraphs
+	c.JSON(resultGraphMap, err)
+}
+
+func queryReGraphAvg(c *bm.Context) {
+	reGraphParam := model.QueryReGraphParam{}
+	if err := c.BindWith(&reGraphParam, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	log.Info("TestNameNicks:(%s)", reGraphParam.TestNameNicks)
+	reportGraphs, err := srv.QueryReGraphAvg(reGraphParam.TestNameNicks)
+	var resultGraphMap = make(map[string][]model.ReportGraph)
+	resultGraphMap["reportGraphs"] = reportGraphs
+	c.JSON(resultGraphMap, err)
+}
+
+func updateReportStatus(c *bm.Context) {
+	testStatus := c.Request.Form.Get("test_status")
+	status, err := strconv.Atoi(testStatus)
+	if err != nil {
+		log.Error("test_status 输入错误，(%s)", err)
+		return
+	}
+	c.JSON(srv.UpdateReportStatus(status), nil)
+}
+
+func delReport(c *bm.Context) {
+	v := new(struct {
+		ID int `form:"id"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	c.JSON(nil, srv.DelReportSummary(v.ID))
+
+}

app/admin/ep/melloi/http/scene.go

@@ -0,0 +1,266 @@
+package http
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+// AddAndExecuScene Add And Execu Scene
+func AddAndExecuScene(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	cookie := c.Request.Header.Get("Cookie")
+	c.JSON(srv.AddAndExecuScene(c, scene, cookie))
+}
+
+func queryDraft(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryDraft(&scene))
+}
+
+func updateScene(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.UpdateScene(&scene))
+}
+
+func addScene(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	id, _ := srv.AddScene(&scene)
+	c.JSON(id, nil)
+}
+
+func saveScene(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.SaveScene(&scene))
+}
+
+func saveOrder(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	var req model.SaveOrderReq
+	if err := c.BindWith(&req, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.SaveOrder(req, &scene))
+}
+
+func queryRelation(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryRelation(&script))
+}
+
+func queryAPI(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryAPI(&scene))
+}
+
+func deleteAPI(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.DeleteAPI(&script))
+}
+
+func addConfig(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.AddConfig(&script))
+}
+
+func queryTree(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryTree(&script))
+}
+
+func queryScenes(c *bm.Context) {
+	qsr := model.QuerySceneRequest{}
+	if err := c.BindWith(&qsr, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	if err := qsr.Verify(); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	sessionID, err := c.Request.Cookie("_AJSESSIONID")
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+
+	res, err := srv.QueryScenesByPage(c, sessionID.Value, &qsr)
+	if err != nil {
+		return
+	}
+	c.JSON(res, err)
+}
+
+func doScenePtest(c *bm.Context) {
+	ptestScene := model.DoPtestSceneParam{}
+	if err := c.BindWith(&ptestScene, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	cookie := c.Request.Header.Get("Cookie")
+	c.JSON(srv.DoScenePtest(c, ptestScene, false, cookie))
+}
+
+func doScenePtestBatch(c *bm.Context) {
+	ptestScenes := model.DoPtestSceneParams{}
+	if err := c.BindWith(&ptestScenes, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	cookie := c.Request.Header.Get("Cookie")
+	c.JSON(nil, srv.DoScenePtestBatch(c, ptestScenes, cookie))
+}
+func queryExistAPI(c *bm.Context) {
+	apiInfoReq := model.APIInfoRequest{}
+	if err := c.BindWith(&apiInfoReq, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	sessionID, err := c.Request.Cookie("_AJSESSIONID")
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryExistAPI(c, sessionID.Value, &apiInfoReq))
+}
+
+func queryPreview(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.Form); err != nil {
+		c.JSON(nil, err)
+	}
+	c.JSON(srv.QueryPreview(&script))
+}
+
+func queryParams(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.Form); err != nil {
+		c.JSON(nil, err)
+	}
+	res, _, err := srv.QueryParams(&script)
+	c.JSON(res, err)
+}
+
+func updateBindScene(c *bm.Context) {
+	bindScene := model.BindScene{}
+	if err := c.BindWith(&bindScene, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.UpdateBindScene(&bindScene))
+}
+
+func queryDrawRelation(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.Form); err != nil {
+		c.JSON(nil, err)
+	}
+	res, _, err := srv.QueryDrawRelation(&scene)
+	c.JSON(res, err)
+}
+
+func addSceneScript(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	cookie := c.Request.Header.Get("Cookie")
+	c.JSON(srv.AddAndExcuScript(c, &script, cookie, &scene, false, false))
+}
+
+func deleteDraft(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.DeleteDraft(&scene))
+}
+
+func queryConfig(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryConfig(&script))
+}
+
+func deleteScene(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.DeleteScene(&scene))
+}
+
+func copyScene(c *bm.Context) {
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	cookie := c.Request.Header.Get("Cookie")
+	c.JSON(srv.CopyScene(c, &scene, cookie))
+}
+
+func queryFusing(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryFusing(&script))
+}

app/admin/ep/melloi/http/script.go

@@ -0,0 +1,226 @@
+package http
+
+import (
+	"encoding/json"
+	"strconv"
+
+	"go-common/app/admin/ep/melloi/conf"
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	"go-common/library/log"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func queryScripts(c *bm.Context) {
+	qsr := model.QueryScriptRequest{}
+	if err := c.BindWith(&qsr, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	qsr.Active = 1
+	if err := qsr.Verify(); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	sessionID, err := c.Request.Cookie("_AJSESSIONID")
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+
+	res, err := srv.QueryScriptsByPage(c, sessionID.Value, &qsr)
+	if err != nil {
+		log.Error("queryScripts Error", err)
+		return
+	}
+	c.JSON(res, err)
+}
+
+func queryScripysFree(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	script.Active = 1
+	res, err := srv.QueryScripts(&script, 1, 200)
+	if err != nil {
+		log.Error("queryScripts Error", err)
+		return
+	}
+	var resMap = make(map[string]interface{})
+	resMap["scripts"] = res
+	c.JSON(resMap, err)
+}
+
+func queryScriptSnap(c *bm.Context) {
+	scriptSnap := model.ScriptSnap{}
+	if err := c.BindWith(&scriptSnap, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	scriptSnaps, err := srv.QueryScriptSnap(&scriptSnap)
+	if err != nil {
+		log.Error("QueryScriptSnap Error", err)
+		return
+	}
+	var resMap = make(map[string]interface{})
+	resMap["scriptSnaps"] = scriptSnaps
+	c.JSON(resMap, nil)
+}
+
+func addJmeterSample(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.AddJmeterSample(&script))
+}
+
+func addThreadGroup(c *bm.Context) {
+	script := model.Script{}
+	sceneTyped := c.Request.Form.Get("scene_type")
+	sceneType, err := strconv.Atoi(sceneTyped)
+	if err != nil {
+		log.Error("your string cannot strconv to int ")
+		return
+	}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.AddThreadGroup(&script, sceneType))
+}
+
+func getThreadGroup(c *bm.Context) {
+	scrThreadGroup := model.ScrThreadGroup{}
+	if err := c.BindWith(&scrThreadGroup, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.GetThreadGroup(scrThreadGroup))
+}
+
+func addAndExecuteScript(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+
+	// 压测时间段检查
+	userName, _ := c.Request.Cookie("username")
+	// 非debug逻辑 && 需要检查 && 非保存 && 非复制
+	if !script.IsDebug && conf.Conf.Melloi.CheckTime && !script.IsSave && !script.IsCopy {
+		//if !srv.CheckRunTime() {
+		//	if !srv.CheckRunPermission(userName.Value) {
+		//		c.JSON("Non-working time", ecode.MelloiRunNotInTime)
+		//		return
+		//	}
+		//}
+		if !srv.CheckRunPermission(userName.Value) {
+			c.JSON("Non-working time", ecode.MelloiRunNotInTime)
+			return
+		}
+	}
+	JSON, _ := json.Marshal(script)
+	log.Info("script:----------", string(JSON))
+	cookie := c.Request.Header.Get("Cookie")
+	resp, err := srv.AddAndExcuScript(c, &script, cookie, &scene, true, false)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(resp, err)
+}
+
+func delScript(c *bm.Context) {
+	id := c.Request.Form.Get("id")
+	ID, err := strconv.Atoi(id)
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.DelScript(ID))
+}
+
+func updateScript(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	updateResult, err := srv.UpdateScript(&script)
+	if err != nil {
+		log.Error("UpdateScript err (%v)", err)
+		return
+	}
+	var resMap = make(map[string]string)
+	resMap["update_result"] = updateResult
+	c.JSON(resMap, err)
+}
+
+func updateScriptAll(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	scene := model.Scene{}
+	if err := c.BindWith(&scene, binding.Form); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	updateResult, err := srv.UpdateScriptAll(&script, &scene)
+	if err != nil {
+		log.Error("UpdateScriptAll err (%v)", err)
+		return
+	}
+	var resMap = make(map[string]string)
+	resMap["update_result"] = updateResult
+	c.JSON(resMap, err)
+}
+
+func runTimeCheck(c *bm.Context) {
+	// 压测时间段检查
+	userName, _ := c.Request.Cookie("username")
+	// 暂时去掉压测时间
+	//if !srv.CheckRunTime() {
+	//	if !srv.CheckRunPermission(userName.Value) {
+	//		c.JSON("Non-working time", ecode.MelloiRunNotInTime)
+	//		return
+	//	}
+	//}
+	if !srv.CheckRunPermission(userName.Value) {
+		c.JSON("Non-working time", ecode.MelloiRunNotInTime)
+		return
+	}
+	c.JSON(nil, nil)
+}
+
+func urlCheck(c *bm.Context) {
+	// 检查url是否包含json串
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.URLCheck(&script))
+}
+
+// 增加定时器配置
+func addTimer(c *bm.Context) {
+	script := model.Script{}
+	if err := c.BindWith(&script, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.AddTimer(&script))
+}

app/admin/ep/melloi/http/tree.go

@@ -0,0 +1,31 @@
+package http
+
+import (
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+)
+
+func queryUserTree(c *bm.Context) {
+	session, err := c.Request.Cookie("_AJSESSIONID")
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryUserTree(c, session.Value))
+}
+
+func queryTreeAdmin(c *bm.Context) {
+	v := new(struct {
+		Path string `form:"path"`
+	})
+	if err := c.Bind(v); err != nil {
+		c.JSON(nil, ecode.RequestErr)
+		return
+	}
+	session, err := c.Request.Cookie("_AJSESSIONID")
+	if err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(srv.QueryTreeAdmin(c, v.Path, session.Value))
+}

app/admin/ep/melloi/http/user.go

@@ -0,0 +1,40 @@
+package http
+
+import (
+	"go-common/app/admin/ep/melloi/model"
+	"go-common/library/ecode"
+	bm "go-common/library/net/http/blademaster"
+	"go-common/library/net/http/blademaster/binding"
+)
+
+func queryUser(c *bm.Context) {
+	// 验证登录sessionID
+	session, err := c.Request.Cookie("_AJSESSIONID")
+	if err != nil {
+		c.JSON(nil, ecode.AccessKeyErr)
+		return
+	}
+
+	token, _ := srv.QueryServiceTreeToken(c, session.Value)
+	if token == "" {
+		c.JSON(nil, ecode.AccessKeyErr)
+		return
+	}
+
+	// 获取用户名
+	userName, err := c.Request.Cookie("username")
+	if err != nil {
+		c.JSON(nil, ecode.AccessKeyErr)
+		return
+	}
+	c.JSON(srv.QueryUser(userName.Value))
+}
+
+func updateUser(c *bm.Context) {
+	user := model.User{}
+	if err := c.BindWith(&user, binding.JSON); err != nil {
+		c.JSON(nil, err)
+		return
+	}
+	c.JSON(nil, srv.UpdateUser(&user))
+}