154 lines
3.6 KiB
Go
154 lines
3.6 KiB
Go
package executor
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"net/url"
|
|
"strings"
|
|
|
|
"gitlink.org.cn/cloudream/common/consts/errorcode"
|
|
"gitlink.org.cn/cloudream/common/pkgs/mq"
|
|
schsdk "gitlink.org.cn/cloudream/common/sdks/scheduler"
|
|
"gitlink.org.cn/cloudream/common/utils/http2"
|
|
"gitlink.org.cn/cloudream/common/utils/serder"
|
|
|
|
schmod "gitlink.org.cn/cloudream/scheduler/common/models"
|
|
exectsk "gitlink.org.cn/cloudream/scheduler/common/pkgs/mq/executor/task"
|
|
)
|
|
|
|
type TaskService interface {
|
|
StartTask(msg *StartTask) (*StartTaskResp, *mq.CodeMessage)
|
|
}
|
|
|
|
// 启动一个任务
|
|
var _ = Register(Service.StartTask)
|
|
|
|
type StartTask struct {
|
|
mq.MessageBodyBase
|
|
TaskID string `json:"taskID"`
|
|
Info exectsk.TaskInfo `json:"info"`
|
|
}
|
|
type StartTaskResp struct {
|
|
mq.MessageBodyBase
|
|
ExecutorID schmod.ExecutorID `json:"executorID"`
|
|
TaskID string `json:"taskID"`
|
|
}
|
|
|
|
func NewStartTask(taskID string, info exectsk.TaskInfo) *StartTask {
|
|
return &StartTask{
|
|
TaskID: taskID,
|
|
Info: info,
|
|
}
|
|
}
|
|
func NewStartTaskResp(execID schmod.ExecutorID, taskID string) *StartTaskResp {
|
|
return &StartTaskResp{
|
|
ExecutorID: execID,
|
|
TaskID: taskID,
|
|
}
|
|
}
|
|
func (c *Client) StartTask(msg *StartTask, opts ...mq.RequestOption) (*StartTaskResp, error) {
|
|
return mq.Request(Service.StartTask, c.rabbitCli, msg, opts...)
|
|
}
|
|
|
|
func (c *HttpClient) SubmitTask(req *StartTask) (*StartTaskResp, error) {
|
|
targetURL, err := url.JoinPath(c.baseURL + "/submitTask")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
data, err := serder.ObjectToJSONEx(req)
|
|
resp, err := http2.PostJSON(targetURL, http2.RequestParam{
|
|
Body: data,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
contType := resp.Header.Get("Content-Type")
|
|
if strings.Contains(contType, http2.ContentTypeJSON) {
|
|
var codeResp response[StartTaskResp]
|
|
if err := serder.JSONToObjectStream(resp.Body, &codeResp); err != nil {
|
|
return nil, fmt.Errorf("parsing response: %w", err)
|
|
}
|
|
|
|
if codeResp.Code == errorcode.OK {
|
|
return &codeResp.Data, nil
|
|
}
|
|
|
|
return nil, codeResp.ToError()
|
|
}
|
|
|
|
return nil, fmt.Errorf("unknow response content type: %s", contType)
|
|
}
|
|
|
|
func (c *HttpClient) GetReportInfo() (*http.Response, error) {
|
|
targetURL, err := url.JoinPath(c.baseURL + "/getReportInfo")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
resp, err := http2.GetJSON(targetURL, http2.RequestParam{
|
|
Body: nil,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
type TaskOperateInfo struct {
|
|
TaskID string
|
|
Operate string
|
|
Runtime schsdk.JobRuntimeInfo
|
|
}
|
|
|
|
func NewTaskOperateInfo(taskID string, operate string, runtime schsdk.JobRuntimeInfo) *TaskOperateInfo {
|
|
return &TaskOperateInfo{
|
|
TaskID: taskID,
|
|
Operate: operate,
|
|
Runtime: runtime,
|
|
}
|
|
}
|
|
|
|
type TaskOperateResp struct {
|
|
Err error
|
|
}
|
|
|
|
func NewTaskOperateResp(err error) *TaskOperateResp {
|
|
return &TaskOperateResp{
|
|
Err: err,
|
|
}
|
|
}
|
|
|
|
func (c *HttpClient) OperateTask(req *TaskOperateInfo) (*TaskOperateResp, error) {
|
|
targetURL, err := url.JoinPath(c.baseURL + "/operateTask")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
data, err := serder.ObjectToJSONEx(req)
|
|
resp, err := http2.PostJSON(targetURL, http2.RequestParam{
|
|
Body: data,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
contType := resp.Header.Get("Content-Type")
|
|
if strings.Contains(contType, http2.ContentTypeJSON) {
|
|
var codeResp response[TaskOperateResp]
|
|
if err := serder.JSONToObjectStream(resp.Body, &codeResp); err != nil {
|
|
return nil, fmt.Errorf("parsing response: %w", err)
|
|
}
|
|
|
|
if codeResp.Code == errorcode.OK {
|
|
return &codeResp.Data, nil
|
|
}
|
|
|
|
return nil, codeResp.ToError()
|
|
}
|
|
|
|
return nil, fmt.Errorf("unknow response content type: %s", contType)
|
|
}
|