数据集导入接口提交

# Conflicts:
#	adaptor/AIComputing/modelarts/rpc/pb/modelarts.proto

adaptor/AIComputing/AICore/api/AICore.api

@@ -0,0 +1,308 @@
+syntax = "v1"
+
+info(
+	title: "AI core"
+	desc: "AI core微服务"
+	author: "wanqgi"
+	email: "1364512070@qq.com"
+)
+/******************find datasetList start*************************/
+
+type DataSet {
+	DatasetId     string        `json:"datasetId"`
+	DataFormat    string        `json:"dataFormat"`
+	DatasetFormat int32         `json:"datasetFormat"`
+	DatasetName   string        `json:"datasetName"`
+	DatasetType   string        `json:"datasetType"`
+	ImportData    bool          `json:"importData"`
+	DataSources   []DataSources `json:"dataSources"`
+}
+
+type DataSources {
+	DataPath string `json:"dataPath"`
+	DataType string `json:"dataType"`
+}
+
+type (
+	listDataSetReq {
+		ProjectId string `json:"projectId"`
+	}
+	listDataSetResp {
+		Code        int32     `json:"code"`
+		Msg         string    `json:"msg"`
+		RecordCount int32     `json:"recordCount"`
+		DataSet     []DataSet `json:"dataSets"`
+	}
+)
+
+/******************find datasetList end*************************/
+/******************ImportTask start*************************/
+type (
+	ImportTaskDataReq {
+		ProjectId  string `json:"projectId"`
+		DatasetId  string `json:"datasetId"`
+		ImportPath string `json:"importPath"`
+	}
+	ImportTaskDataResp {
+		TaskId string `json:"taskId"`
+	}
+)
+/******************ImportTask end*************************/
+/******************taskList start*************************/
+type (
+	ListImportTasksReq {
+		ProjectId string `json:"projectId"`
+		DatasetId string `json:"datasetId"`
+		Limit     int32  `json:"limit,optional"`
+		Offset    int32  `json:"offset,optional"`
+	}
+	ListImportTasksResp {
+		TotalCount  uint32        `json:"totalCount"`
+		ImportTasks []ImportTasks `json:"importTasks"`
+	}
+)
+type ImportTasks {
+	Status                 string        `json:"status,omitempty"`
+	TaskId                 string        `json:"task_id,omitempty"`
+	DatasetId              string        `json:"dataset_id,omitempty"`
+	ImportPath             string        `json:"import_path,omitempty"`
+	ImportType             int32         `json:"import_type,omitempty"`
+	TotalSampleCount       uint32        `json:"total_sample_count,omitempty"`
+	ImportedSampleCount    uint32        `json:"imported_sample_count,omitempty"`
+	AnnotatedSampleCount   uint32        `json:"annotated_sample_count,omitempty"`
+	TotalSubSampleCount    uint32        `json:"total_sub_sample_count,omitempty"`
+	ImportedSubSampleCount uint32        `json:"imported_sub_sample_count,omitempty"`
+	TotalFileSize          uint32        `json:"total_file_size,omitempty"`
+	FinishedFileCount      uint32        `json:"finished_file_count,omitempty"`
+	FinishedFileSize       uint32        `json:"finished_file_size,omitempty"`
+	TotalFileCount         uint32        `json:"total_file_count,omitempty"`
+	CreateTime             uint32        `json:"create_time,omitempty"`
+	ElapsedTime            uint32        `json:"elapsed_time,omitempty"`
+	AnnotationFormatConfig []interface{} `json:"annotation_format_config"`
+}
+/******************taskList end*************************/
+/******************ListTrainingJobs start*************************/
+type Annotations {
+	JobTemplate string `json:"job_template"`
+	KeyTask     string `json:"key_task"`
+}
+type TrainingExperimentReference {
+}
+type Metadata {
+	ID                          string                      `json:"id"`
+	Name                        string                      `json:"name"`
+	Description                 string                      `json:"description"`
+	CreateTime                  uint32                      `json:"create_time"`
+	WorkspaceID                 string                      `json:"workspace_id"`
+	AiProject                   string                      `json:"ai_project"`
+	UserName                    string                      `json:"user_name"`
+	Annotations                 Annotations                 `json:"annotations"`
+	TrainingExperimentReference TrainingExperimentReference `json:"training_experiment_reference"`
+	Tags                        []interface{}               `json:"tags"`
+}
+type CPUUsage {
+	Average int32 `json:"average"`
+	Max     int32 `json:"max"`
+	Min     int32 `json:"min"`
+}
+type MemUsage {
+	Average int32 `json:"average"`
+	Max     int32 `json:"max"`
+	Min     int32 `json:"min"`
+}
+type Util {
+	Average int32 `json:"average"`
+	Max     int32 `json:"max"`
+	Min     int32 `json:"min"`
+}
+type Gpu {
+	MemUsage    MemUsage `json:"mem_usage"`
+	Util        Util     `json:"util"`
+	UnitNum     int32    `json:"unit_num"`
+	ProductName string   `json:"product_name"`
+	Memory      string   `json:"memory"`
+}
+type MetricsStatistics {
+	CPUUsage CPUUsage `json:"cpu_usage"`
+	Gpu      Gpu      `json:"gpu"`
+	MemUsage MemUsage `json:"mem_usage"`
+}
+type Status {
+	Phase          string `json:"phase"`
+	SecondaryPhase string `json:"secondary_phase"`
+	Duration       int32  `json:"duration"`
+	IsHanged       bool   `json:"is_hanged"`
+	RetryCount     int32  `json:"retry_count"`
+	StartTime      int32  `json:"start_time"`
+	//	NodeCountMetrics []NodeCountMetrics[]interface{} `json:"node_count_metrics"`
+	Tasks             []string          `json:"tasks"`
+	MetricsStatistics MetricsStatistics `json:"metrics_statistics"`
+}
+
+type Constraint {
+	Type       string      `json:"type"`
+	Editable   bool        `json:"editable"`
+	Required   bool        `json:"required"`
+	Sensitive  bool        `json:"sensitive"`
+	ValidType  string      `json:"valid_type"`
+	ValidRange interface{} `json:"valid_range"`
+}
+type Parameters {
+	Name            string      `json:"name"`
+	Description     string      `json:"description"`
+	I18NDescription interface{} `json:"i18n_description"`
+	Value           string      `json:"value"`
+	Constraint      Constraint  `json:"constraint"`
+}
+type Obs {
+	ObsURL string `json:"obs_url"`
+}
+type Remote {
+	Obs Obs `json:"obs"`
+}
+type Attributes {
+	DataFormat       []string `json:"data_format"`
+	DataSegmentation []string `json:"data_segmentation"`
+	DatasetType      []string `json:"dataset_type"`
+	IsFree           string   `json:"is_free"`
+	MaxFreeJobCount  string   `json:"max_free_job_count"`
+}
+type RemoteConstraints {
+	DataType   string     `json:"data_type"`
+	Attributes Attributes `json:"attributes,omitempty"`
+}
+type Inputs {
+	Name              string              `json:"name"`
+	Description       string              `json:"description"`
+	LocalDir          string              `json:"local_dir"`
+	AccessMethod      string              `json:"access_method"`
+	Remote            Remote              `json:"remote"`
+	RemoteConstraints []RemoteConstraints `json:"remote_constraints"`
+}
+type Outputs {
+	Name            string `json:"name"`
+	LocalDir        string `json:"local_dir"`
+	AccessMethod    string `json:"access_method"`
+	Remote          Remote `json:"remote"`
+	Mode            string `json:"mode"`
+	Period          int32  `json:"period"`
+	PrefetchToLocal bool   `json:"prefetch_to_local"`
+}
+type Engine {
+	EngineID      string `json:"engine_id"`
+	EngineName    string `json:"engine_name"`
+	EngineVersion string `json:"engine_version"`
+	V1Compatible  bool   `json:"v1_compatible"`
+	RunUser       string `json:"run_user"`
+	ImageSource   bool   `json:"image_source"`
+}
+type Policies {
+}
+type Algorithm {
+	ID                      string       `json:"id"`
+	Name                    string       `json:"name"`
+	V1Algorithm             bool         `json:"v1_algorithm"`
+	SubscriptionID          string       `json:"subscription_id"`
+	ItemVersionID           string       `json:"item_version_id"`
+	ContentID               string       `json:"content_id"`
+	Parameters              []Parameters `json:"parameters"`
+	ParametersCustomization bool         `json:"parameters_customization"`
+	Inputs                  []Inputs     `json:"inputs"`
+	Outputs                 []Outputs    `json:"outputs"`
+	Engine                  Engine       `json:"engine"`
+	Policies                Policies     `json:"policies"`
+}
+type Billing {
+	Code    string `json:"code"`
+	UnitNum int32  `json:"unit_num"`
+}
+type CPU {
+	Arch    string `json:"arch"`
+	CoreNum int32  `json:"core_num"`
+}
+type Memory {
+	Size int    `json:"size"`
+	Unit string `json:"unit"`
+}
+type Disk {
+	Size int32  `json:"size"`
+	Unit string `json:"unit"`
+}
+type FlavorInfo {
+	CPU    CPU    `json:"cpu"`
+	Gpu    Gpu    `json:"gpu"`
+	Memory Memory `json:"memory"`
+	Disk   Disk   `json:"disk"`
+}
+type FlavorDetail {
+	FlavorType string     `json:"flavor_type"`
+	Billing    Billing    `json:"billing"`
+	Attributes Attributes `json:"attributes"`
+	FlavorInfo FlavorInfo `json:"flavor_info"`
+}
+type Resource {
+	Policy       string       `json:"policy"`
+	FlavorID     string       `json:"flavor_id"`
+	FlavorName   string       `json:"flavor_name"`
+	NodeCount    int32        `json:"node_count"`
+	FlavorDetail FlavorDetail `json:"flavor_detail"`
+}
+type LogExportPath {
+}
+type Spec {
+	Resource      Resource      `json:"resource"`
+	LogExportPath LogExportPath `json:"log_export_path"`
+	IsHostedLog   bool          `json:"is_hosted_log"`
+}
+type Items {
+	Kind      string    `json:"kind"`
+	Metadata  Metadata  `json:"metadata"`
+	Status    Status    `json:"status"`
+	Algorithm Algorithm `json:"algorithm,omitempty"`
+	Spec      Spec      `json:"spec"`
+}
+type (
+	ListTrainingJobsreq {
+		ProjectId string `json:"projectId"`
+	}
+	ListTrainingJobsresp {
+		Total       int32   `json:"total"`
+		Count       int32   `json:"count"`
+		Limit       int32   `json:"limit"`
+		Offset      int32   `json:"offset"`
+		SortBy      string  `json:"sort_by"`
+		Order       string  `json:"order"`
+		GroupBy     string  `json:"group_by"`
+		WorkspaceID string  `json:"workspace_id"`
+		AiProject   string  `json:"ai_project"`
+		Items       []Items `json:"items"`
+	}
+)
+/******************ListTrainingJobs end*************************/
+
+/******************CreateTrainingJob start*************************/
+type (
+	CreateTrainingJobReq {
+		ProjectId string `json:"projectId"`
+	}
+	CreateTrainingJobResp {
+	}
+)
+/******************CreateTrainingJob end*************************/
+service AICore-api {
+	
+	@handler listDataSetHandler
+	get /listDataSet (listDataSetReq) returns (listDataSetResp)
+	//	creat task  创建导入任务
+	@handler CreateTaskHandler
+	post /CreateTask (ImportTaskDataReq) returns (ImportTaskDataResp)
+	//	get taskList 查询数据集导入任务列表
+	@handler ListImportHandler
+	get /ListImport (ListImportTasksReq) returns (ListImportTasksResp)
+	//	ListTrainingJobs 查询训练作业列表
+	@handler ListTrainingJobsreq
+	get /GetListTrainingJobs (ListTrainingJobsreq) returns (ListTrainingJobsresp)
+	//   CreateTrainingJob 创建训练作业
+	@handler CreateTrainingJobHandler
+	post /CreateTrainingJob (CreateTrainingJobReq) returns (CreateTrainingJobResp)
+}

adaptor/AIComputing/AICore/api/aicore.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/config"
+	"PCM/adaptor/AIComputing/AICore/api/internal/handler"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+
+	"github.com/zeromicro/go-zero/core/conf"
+	"github.com/zeromicro/go-zero/rest"
+)
+
+var configFile = flag.String("f", "adaptor/AIComputing/AICore/api/etc/aicore-api.yaml", "the config file")
+
+func main() {
+	flag.Parse()
+
+	var c config.Config
+	conf.MustLoad(*configFile, &c)
+
+	server := rest.MustNewServer(c.RestConf)
+	defer server.Stop()
+
+	ctx := svc.NewServiceContext(c)
+	handler.RegisterHandlers(server, ctx)
+
+	fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
+	server.Start()
+}

adaptor/AIComputing/AICore/api/etc/aicore-api.yaml

@@ -0,0 +1,9 @@
+Name: AICore-api
+Host: 0.0.0.0
+Port: 8888
+
+#rpc by wangqi
+ModelartsRpcConf:
+  Endpoints:
+    - 127.0.0.1:2003
+  NonBlock: true

adaptor/AIComputing/AICore/api/internal/config/config.go

@@ -0,0 +1,12 @@
+package config
+
+import (
+	"github.com/zeromicro/go-zero/rest"
+	"github.com/zeromicro/go-zero/zrpc"
+)
+
+type Config struct {
+	rest.RestConf
+
+	ModelartsRpcConf zrpc.RpcClientConf
+}

adaptor/AIComputing/AICore/api/internal/handler/createtaskhandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func CreateTaskHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ImportTaskDataReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewCreateTaskLogic(r.Context(), svcCtx)
+		resp, err := l.CreateTask(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/listdatasethandler.go

@@ -0,0 +1,28 @@
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/logic"
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+	"github.com/zeromicro/go-zero/rest/httpx"
+)
+
+func listDataSetHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req types.ListDataSetReq
+		if err := httpx.Parse(r, &req); err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+			return
+		}
+
+		l := logic.NewListDataSetLogic(r.Context(), svcCtx)
+		resp, err := l.ListDataSet(&req)
+		if err != nil {
+			httpx.ErrorCtx(r.Context(), w, err)
+		} else {
+			httpx.OkJsonCtx(r.Context(), w, resp)
+		}
+	}
+}

adaptor/AIComputing/AICore/api/internal/handler/routes.go

@@ -0,0 +1,32 @@
+// Code generated by goctl. DO NOT EDIT.
+package handler
+
+import (
+	"net/http"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+
+	"github.com/zeromicro/go-zero/rest"
+)
+
+func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
+	server.AddRoutes(
+		[]rest.Route{
+			{
+				Method:  http.MethodGet,
+				Path:    "/listDataSet",
+				Handler: listDataSetHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/createDataSet",
+				Handler: CreateDataSetHandler(serverCtx),
+			},
+			{
+				Method:  http.MethodPost,
+				Path:    "/CreateTask",
+				Handler: CreateTaskHandler(serverCtx),
+			},
+		},
+	)
+}

adaptor/AIComputing/AICore/api/internal/logic/createtasklogic.go

@@ -0,0 +1,50 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTaskLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTaskLogic {
+	return &CreateTaskLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateTaskLogic) CreateTask(req *types.ImportTaskDataReq) (resp *types.ImportTaskDataResp, err error) {
+
+	modelartsReq := &modelarts.ImportTaskDataReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	ImportTaskDataResp, err := l.svcCtx.ModelArtsRpc.CreateTask(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ImportTaskDataResp{}
+
+	err = copier.CopyWithOption(&resp, &ImportTaskDataResp, copier.Option{Converters: tool.Converters})
+	/*if err != nil {
+		return nil, err
+	}
+	for i := range resp.DataSet {
+		resp.DataSet[i]. = "modelarts"
+	}*/
+
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/createtrainingjoblogic.go

@@ -0,0 +1,30 @@
+package logic
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTrainingJobLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewCreateTrainingJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTrainingJobLogic {
+	return &CreateTrainingJobLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CreateTrainingJobLogic) CreateTrainingJob(req *types.CreateTrainingJobReq) (resp *types.CreateTrainingJobResp, err error) {
+	// todo: add your logic here and delete this line
+
+	return
+}

adaptor/AIComputing/AICore/api/internal/logic/listdatasetlogic.go

@@ -0,0 +1,54 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListDataSetLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListDataSetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListDataSetLogic {
+	return &ListDataSetLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListDataSetLogic) ListDataSet(req *types.ListDataSetReq) (resp *types.ListDataSetResp, err error) {
+	// todo: add your logic here and delete this line
+	modelartsReq := &modelarts.DatasetReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	listDataSetResp, err := l.svcCtx.ModelArtsRpc.GetDatasetList(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ListDataSetResp{}
+	for i := 0; i < len(listDataSetResp.Datasets); i++ {
+		historyJob := types.DataSet{}
+		resp.DataSet = append(resp.DataSet, historyJob)
+	}
+
+	err = copier.CopyWithOption(&resp, &listDataSetResp, copier.Option{Converters: tool.Converters})
+	/*if err != nil {
+		return nil, err
+	}
+	for i := range resp.DataSet {
+		resp.DataSet[i]. = "modelarts"
+	}*/
+
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/listimportlogic.go

@@ -0,0 +1,53 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListImportLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListImportLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListImportLogic {
+	return &ListImportLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListImportLogic) ListImport(req *types.ListImportTasksReq) (resp *types.ListImportTasksResp, err error) {
+	modelartsReq := &modelarts.ListImportTasksReq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	listDataSetResp, err := l.svcCtx.ModelArtsRpc.GetImportTaskList(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ListImportTasksResp{}
+	for i := 0; i < len(listDataSetResp.ImportTasks); i++ {
+		historyJob := types.ImportTasks{}
+		resp.ImportTasks = append(resp.ImportTasks, historyJob)
+	}
+
+	err = copier.CopyWithOption(&resp, &listDataSetResp, copier.Option{Converters: tool.Converters})
+	/*if err != nil {
+		return nil, err
+	}
+	for i := range resp.DataSet {
+		resp.DataSet[i]. = "modelarts"
+	}*/
+
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/logic/listtrainingjobsreqlogic.go

@@ -0,0 +1,53 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"PCM/common/xerr"
+	"context"
+	"github.com/jinzhu/copier"
+	"github.com/pkg/errors"
+
+	"PCM/adaptor/AIComputing/AICore/api/internal/svc"
+	"PCM/adaptor/AIComputing/AICore/api/internal/types"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListTrainingJobsreqLogic struct {
+	logx.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+func NewListTrainingJobsreqLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListTrainingJobsreqLogic {
+	return &ListTrainingJobsreqLogic{
+		Logger: logx.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ListTrainingJobsreqLogic) ListTrainingJobsreq(req *types.ListTrainingJobsreq) (resp *types.ListTrainingJobsresp, err error) {
+	modelartsReq := &modelarts.ListTrainingJobsreq{}
+	err = copier.CopyWithOption(modelartsReq, req, copier.Option{Converters: tool.Converters})
+	listDataSetResp, err := l.svcCtx.ModelArtsRpc.GetListTrainingJobs(l.ctx, modelartsReq)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrMsg("Failed to get db DataSet list"), "Failed to get db DataSet list err : %v ,req:%+v", err, req)
+	}
+	resp = &types.ListTrainingJobsresp{}
+	for i := 0; i < len(listDataSetResp.Items); i++ {
+		historyJob := types.Items{}
+		resp.Items = append(resp.Items, historyJob)
+	}
+
+	err = copier.CopyWithOption(&resp, &listDataSetResp, copier.Option{Converters: tool.Converters})
+	/*if err != nil {
+		return nil, err
+	}
+	for i := range resp.DataSet {
+		resp.DataSet[i]. = "modelarts"
+	}*/
+
+	return resp, nil
+}

adaptor/AIComputing/AICore/api/internal/svc/servicecontext.go

@@ -0,0 +1,21 @@
+package svc
+
+import (
+	"PCM/adaptor/AIComputing/AICore/api/internal/config"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelartsclient"
+	"github.com/zeromicro/go-zero/zrpc"
+)
+
+type ServiceContext struct {
+	Config config.Config
+
+	ModelArtsRpc modelartsclient.ModelArts
+}
+
+func NewServiceContext(c config.Config) *ServiceContext {
+	return &ServiceContext{
+		Config: c,
+
+		ModelArtsRpc: modelartsclient.NewModelArts(zrpc.MustNewClient(c.ModelartsRpcConf)),
+	}
+}

adaptor/AIComputing/AICore/api/internal/types/types.go

@@ -0,0 +1,53 @@
+// Code generated by goctl. DO NOT EDIT.
+package types
+
+type DataSet struct {
+	DatasetId     string        `json:"datasetId"`
+	DataFormat    string        `json:"dataFormat"`
+	DatasetFormat int32         `json:"datasetFormat"`
+	DatasetName   string        `json:"datasetName"`
+	DatasetType   string        `json:"datasetType"`
+	ImportData    bool          `json:"importData"`
+	DataSources   []DataSources `json:"dataSources"`
+}
+
+type DataSources struct {
+	DataPath string `json:"dataPath"`
+	DataType string `json:"dataType"`
+}
+
+type ListDataSetReq struct {
+	ProjectId string `json:"projectId"`
+}
+
+type ListDataSetResp struct {
+	Code        int32     `json:"code"`
+	Msg         string    `json:"msg"`
+	RecordCount int32     `json:"recordCount"`
+	DataSet     []DataSet `json:"dataSets"`
+}
+
+type ImportTaskDataReq struct {
+	ProjectId  string `json:"projectId"`
+	DatasetId  string `json:"datasetId"`
+	ImportPath string `json:"importPath"`
+}
+
+type ImportTaskDataResp struct {
+	TaskId string `json:"TaskId"`
+}
+
+type CreateDataSetReq struct {
+	DatasetId    string        `json:"datasetId"`
+	DatasetType  int32         `json:"datasetType"`
+	Description  string        `json:"description"`
+	WorkPath     string        `json:"workPath"`
+	DatasetName  string        `json:"datasetName"`
+	WorkPathType string        `json:"workPathType"`
+	ProjectId    string        `json:"projectId"`
+	DataSources  []DataSources `json:"DataSources"`
+}
+
+type CreateDataSetResp struct {
+	Dataset_id string `json:"datasetId"`
+}

adaptor/AIComputing/modelarts/rpc/etc/modelarts.yaml

@@ -0,0 +1,4 @@
+Name: modelarts.rpc
+ListenOn: 0.0.0.0:2003
+
+modelartsUrl: "https://modelarts.cn-north-4.myhuaweicloud.com/"

adaptor/AIComputing/modelarts/rpc/internal/common/AuthService.go

@@ -0,0 +1,69 @@
+package common
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"log"
+	"net/http"
+	"time"
+)
+
+const (
+	IAMUser        = "pcmmodelarts"
+	IAMPassword    = "!QAZ2wsx3edc4"
+	IAMDomain      = "hw_008618597947378_01"
+	AuthMethod     = "password"
+	IAMTokenUrl    = "https://iam.cn-north-4.myhuaweicloud.com/v3/auth/tokens"
+	ProjectName    = "cn-north-4"
+	TokenHeader    = "X-Subject-Token"
+	Status_created = 201
+)
+
+var (
+	token, expiredAt = GenerateToken()
+)
+
+func GenerateToken() (string, time.Time) {
+	a := Auth{}
+	a.Auth.Scope.Project.Name = ProjectName
+	a.Auth.Identity.Methods = append(a.Auth.Identity.Methods, AuthMethod)
+	a.Auth.Identity.Password.User.Name = IAMUser
+	a.Auth.Identity.Password.User.Password = IAMPassword
+	a.Auth.Identity.Password.User.Domain.Name = IAMDomain
+
+	jsonStr, _ := json.Marshal(a)
+	req_url, err := http.NewRequest("POST", IAMTokenUrl, bytes.NewBuffer(jsonStr))
+
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer req_url.Body.Close()
+
+	c := http.Client{Timeout: time.Duration(3) * time.Second}
+
+	respUrl, err := c.Do(req_url)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if respUrl.StatusCode != Status_created {
+		panic("获取token失败")
+	}
+
+	defer respUrl.Body.Close()
+
+	var t Token
+
+	result, _ := io.ReadAll(respUrl.Body)
+	json.Unmarshal(result, &t)
+
+	return respUrl.Header.Get(TokenHeader), t.Token.ExpiresAt
+}
+
+func GetToken() string {
+	if time.Now().After(expiredAt) {
+		token, expiredAt = GenerateToken()
+	}
+	return token
+}

adaptor/AIComputing/modelarts/rpc/internal/common/Entity.go

@@ -0,0 +1,66 @@
+package common
+
+import "time"
+
+type Token struct {
+	Token struct {
+		ExpiresAt time.Time `json:"expires_at"`
+		Methods   []string  `json:"methods"`
+		Catalog   []struct {
+			Endpoints []struct {
+				Id        string `json:"id"`
+				Interface string `json:"interface"`
+				Region    string `json:"region"`
+				RegionId  string `json:"region_id"`
+				Url       string `json:"url"`
+			} `json:"endpoints"`
+			Id   string `json:"id"`
+			Name string `json:"name"`
+			Type string `json:"type"`
+		} `json:"catalog"`
+		Roles []struct {
+			Id   string `json:"id"`
+			Name string `json:"name"`
+		} `json:"roles"`
+		Project struct {
+			Domain struct {
+				Id   string `json:"id"`
+				Name string `json:"name"`
+			} `json:"domain"`
+			Id   string `json:"id"`
+			Name string `json:"name"`
+		} `json:"project"`
+		IssuedAt time.Time `json:"issued_at"`
+		User     struct {
+			Domain struct {
+				Id   string `json:"id"`
+				Name string `json:"name"`
+			} `json:"domain"`
+			Id                string `json:"id"`
+			Name              string `json:"name"`
+			PasswordExpiresAt string `json:"password_expires_at"`
+		} `json:"user"`
+	} `json:"token"`
+}
+
+type Auth struct {
+	Auth struct {
+		Identity struct {
+			Methods  []string `json:"methods"`
+			Password struct {
+				User struct {
+					Name     string `json:"name"`
+					Password string `json:"password"`
+					Domain   struct {
+						Name string `json:"name"`
+					} `json:"domain"`
+				} `json:"user"`
+			} `json:"password"`
+		} `json:"identity"`
+		Scope struct {
+			Project struct {
+				Name string `json:"name"`
+			} `json:"project"`
+		} `json:"scope"`
+	} `json:"auth"`
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createalgorithmlogic.go

@@ -0,0 +1,49 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateAlgorithmLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateAlgorithmLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateAlgorithmLogic {
+	return &CreateAlgorithmLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// CreateAlgorithm 创建算法
+func (l *CreateAlgorithmLogic) CreateAlgorithm(in *modelarts.CreateAlgorithmReq) (*modelarts.CreateAlgorithmResp, error) {
+	var resp modelarts.CreateAlgorithmResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/algorithms"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createdatasetlogic.go

@@ -0,0 +1,50 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateDataSetLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateDataSetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateDataSetLogic {
+	return &CreateDataSetLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// create  DateSet
+func (l *CreateDataSetLogic) CreateDataSet(in *modelarts.CreateDataSetReq) (*modelarts.CreateDataSetResq, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.CreateDataSetResq
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createmodellogic.go

@@ -0,0 +1,52 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateModelLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateModelLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateModelLogic {
+	return &CreateModelLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// model management
+func (l *CreateModelLogic) CreateModel(in *modelarts.CreateModelReq) (*modelarts.CreateModelResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.CreateModelResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/models"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createprocessortasklogic.go

@@ -0,0 +1,52 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateProcessorTaskLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateProcessorTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateProcessorTaskLogic {
+	return &CreateProcessorTaskLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// processor task
+func (l *CreateProcessorTaskLogic) CreateProcessorTask(in *modelarts.CreateProcessorTaskReq) (*modelarts.CreateProcessorTaskResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.CreateProcessorTaskResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/processor-tasks/"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createservicelogic.go

@@ -0,0 +1,53 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"github.com/zeromicro/go-zero/core/logx"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+)
+
+import (
+	"context"
+)
+
+type CreateServiceLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateServiceLogic {
+	return &CreateServiceLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// service management
+func (l *CreateServiceLogic) CreateService(in *modelarts.CreateServiceReq) (*modelarts.CreateServiceResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.CreateServiceResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/services"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createtasklogic.go

@@ -0,0 +1,50 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTaskLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTaskLogic {
+	return &CreateTaskLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// creat task 创建导入任务
+func (l *CreateTaskLogic) CreateTask(in *modelarts.ImportTaskDataReq) (*modelarts.ImportTaskDataResp, error) {
+	var resp modelarts.ImportTaskDataResp
+
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets/" + in.DatasetId + "/import-tasks"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createtrainingjobconfiglogic.go

@@ -0,0 +1,49 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTrainingJobConfigLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateTrainingJobConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTrainingJobConfigLogic {
+	return &CreateTrainingJobConfigLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// CreateTrainingJobConfig 创建训练作业参数
+func (l *CreateTrainingJobConfigLogic) CreateTrainingJobConfig(in *modelarts.CreateTrainingJobConfigReq) (*modelarts.CreateTrainingJobConfigResp, error) {
+	var resp modelarts.CreateTrainingJobConfigResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/training-job-configs"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/createtrainingjoblogic.go

@@ -0,0 +1,49 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type CreateTrainingJobLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewCreateTrainingJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateTrainingJobLogic {
+	return &CreateTrainingJobLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// CreateTrainingJob 创建训练作业
+func (l *CreateTrainingJobLogic) CreateTrainingJob(in *modelarts.CreateTrainingJobReq) (*modelarts.CreateTrainingJobResp, error) {
+	var resp modelarts.CreateTrainingJobResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/training-jobs"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deletemodellogic.go

@@ -0,0 +1,51 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteModelLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteModelLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteModelLogic {
+	return &DeleteModelLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *DeleteModelLogic) DeleteModel(in *modelarts.DeleteModelReq) (*modelarts.DeleteModelResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.DeleteModelResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/models/" + in.ModelId
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.DELETE, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deleteservicelogic.go

@@ -0,0 +1,44 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteServiceLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteServiceLogic {
+	return &DeleteServiceLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *DeleteServiceLogic) DeleteService(in *modelarts.DeleteServiceReq) (*modelarts.DeleteServiceResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.DeleteServiceResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/services/" + in.ServiceId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.DELETE, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deletetrainingjobconfiglogic.go

@@ -0,0 +1,43 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteTrainingJobConfigLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteTrainingJobConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteTrainingJobConfigLogic {
+	return &DeleteTrainingJobConfigLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// DeleteTrainingJobConfig 删除训练作业参数
+func (l *DeleteTrainingJobConfigLogic) DeleteTrainingJobConfig(in *modelarts.DeleteTrainingJobConfigReq) (*modelarts.DeleteTrainingJobConfigResp, error) {
+	var resp modelarts.DeleteTrainingJobConfigResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/training-job-configs/" + in.ConfigName
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.DELETE, url, strings.NewReader(``), token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/deletetrainingjoblogic.go

@@ -0,0 +1,44 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DeleteTrainingJobLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDeleteTrainingJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteTrainingJobLogic {
+	return &DeleteTrainingJobLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// DeleteTrainingJobConfig 删除训练作业
+func (l *DeleteTrainingJobLogic) DeleteTrainingJob(in *modelarts.DeleteTrainingJobReq) (*modelarts.DeleteTrainingJobResp, error) {
+	var resp modelarts.DeleteTrainingJobResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/training-jobs/" + in.TrainingJobId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.DELETE, url, strings.NewReader(``), token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	if &resp == nil {
+		return nil, err
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/describeprocessortasklogic.go

@@ -0,0 +1,44 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type DescribeProcessorTaskLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewDescribeProcessorTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DescribeProcessorTaskLogic {
+	return &DescribeProcessorTaskLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *DescribeProcessorTaskLogic) DescribeProcessorTask(in *modelarts.DescribeProcessorTaskReq) (*modelarts.DescribeProcessorTaskResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.DescribeProcessorTaskResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/processor-tasks/" + in.TaskId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/exporttasklogic.go

@@ -0,0 +1,53 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	_ "PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ExportTaskLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewExportTaskLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ExportTaskLogic {
+	return &ExportTaskLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// ExportTask for modelarts
+func (l *ExportTaskLogic) ExportTask(in *modelarts.ExportTaskReq) (*modelarts.ExportTaskResp, error) {
+	var resp modelarts.ExportTaskResp
+
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets/" + in.DatasetId + "/export-tasks"
+	reqByte, err := json.Marshal(in)
+	if err != nil {
+		return nil, err
+	}
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getdatasetlistlogic.go

@@ -0,0 +1,40 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"github.com/zeromicro/go-zero/core/logx"
+	"k8s.io/apimachinery/pkg/util/json"
+	"log"
+	"strings"
+)
+
+type GetDatasetListLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetDatasetListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetDatasetListLogic {
+	return &GetDatasetListLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// find datasetList
+func (l *GetDatasetListLogic) GetDatasetList(in *modelarts.DatasetReq) (*modelarts.DatasetResp, error) {
+	projectId := in.ProjectId
+	var resp modelarts.DatasetResp
+	token := common.GetToken()
+	reqUrl, err := tool.HttpClient(tool.GET, "https://modelarts.cn-north-4.myhuaweicloud.com/v2/"+projectId+"/datasets", strings.NewReader(``), token)
+	json.Unmarshal(reqUrl, &resp)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getexporttasksofdatasetlogic.go

@@ -0,0 +1,51 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetExportTasksOfDatasetLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetExportTasksOfDatasetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetExportTasksOfDatasetLogic {
+	return &GetExportTasksOfDatasetLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+//type Pppp struct {
+//	TotalCount  int                           `json:"total_count"`
+//	ExportTasks []*Modelarts.ExportTaskStatus `json:"export_tasks"`
+//}
+
+func (l *GetExportTasksOfDatasetLogic) GetExportTasksOfDataset(in *modelarts.GetExportTasksOfDatasetReq) (*modelarts.GetExportTasksOfDatasetResp, error) {
+
+	var resp modelarts.GetExportTasksOfDatasetResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets/" + in.DatasetId + "/export-tasks"
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	//	var resp Pppp
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getexporttaskstatusofdatasetlogic.go

@@ -0,0 +1,47 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetExportTaskStatusOfDatasetLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetExportTaskStatusOfDatasetLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetExportTaskStatusOfDatasetLogic {
+	return &GetExportTaskStatusOfDatasetLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *GetExportTaskStatusOfDatasetLogic) GetExportTaskStatusOfDataset(in *modelarts.GetExportTaskStatusOfDatasetReq) (*modelarts.GetExportTaskStatusOfDatasetResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.GetExportTaskStatusOfDatasetResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/datasets/" + in.ResourceId + "/export-tasks/" + in.TaskId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	//	var resp Pppp
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getimporttasklistlogic.go

@@ -0,0 +1,91 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+	"log"
+	"strconv"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetImportTaskListLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetImportTaskListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetImportTaskListLogic {
+	return &GetImportTaskListLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// find taskList 查询数据集导入任务列表
+func (l *GetImportTaskListLogic) GetImportTaskList(in *modelarts.ListImportTasksReq) (*modelarts.ListImportTasksResp, error) {
+	datasetId := in.DatasetId
+	projectId := in.ProjectId
+	limit := strconv.Itoa(int(in.Limit))
+	offset := strconv.Itoa(int(in.Offset))
+	var resp modelarts.ListImportTasksResp
+	token := common.GetToken()
+	//c := http.Client{Timeout: time.Duration(3) * time.Second}
+	reqUrl, err := tool.HttpClient(tool.GET, "https://modelarts.cn-north-4.myhuaweicloud.com/v2/"+projectId+"/datasets/"+datasetId+"/import-tasks?"+limit+"&"+offset, strings.NewReader(``), token)
+
+	json.Unmarshal(reqUrl, &resp)
+	//reqUrl.Header.Add("X-Auth-Token", token)
+	//reqUrl.Header.Add("User-Agent", "API Explorer")
+	//reqUrl.Header.Add("Content-Type", "application/json;charset=UTF-8")
+	//respUrl, err := c.Do(reqUrl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	//defer respUrl.Body.Close()
+	//body, err := ioutil.ReadAll(respUrl.Body)
+	//jsonResult, err := simplejson.NewJson(body)
+	//if jsonResult.Get("total_count").MustInt() == 0 {
+	//	resp.TotalCount = 0
+	//	resp.ImportTasks = nil
+	//	return &resp, nil
+	//}
+	//var Jobs []*modelarts.ImportTasks
+	//taskList := jsonResult.Get("import_tasks")
+	//rows, err := taskList.Array()
+	//for index := range rows {
+	//	task := taskList.GetIndex(index)
+	//	var job modelarts.ImportTasks
+	//	var dataSource modelarts.DataSource
+	//	//var demo modelarts.AnnotationFormatConfig
+	//	job.Status = task.Get("status").MustString()
+	//	job.TaskId = task.Get("task_id").MustString()
+	//	job.DatasetId = task.Get("dataset_id").MustString()
+	//	job.ImportPath = task.Get("import_path").MustString()
+	//	job.ImportType = int32(task.Get("import_type").MustInt())
+	//	job.TotalSampleCount = uint32(task.Get("total_sample_count").MustInt())
+	//	job.ImportedSampleCount = uint32(task.Get("imported_sample_count").MustInt())
+	//	job.AnnotatedSampleCount = uint32(task.Get("annotated_sample_count").MustInt())
+	//	job.CreateTime = uint32(task.Get("annotated_sample_count").MustInt())
+	//	job.ElapsedTime = uint32(task.Get("elapsed_time").MustInt())
+	//	dataList := task.Get("data_source")
+	//	dataSource.DataType = int32(dataList.Get("data_type").MustInt())
+	//	dataSource.DataPath = dataList.Get("data_path").MustString()
+	//	if err != nil {
+	//		log.Fatal(err)
+	//	}
+	//	job.DataSource = &dataSource
+	//	Jobs = append(Jobs, &job)
+	//}
+	//
+	//resp.TotalCount = uint32(jsonResult.Get("total_count").MustInt())
+	//resp.ImportTasks = Jobs
+	return &resp, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/getlisttrainingjobslogic.go

@@ -0,0 +1,46 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"github.com/bitly/go-simplejson"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strings"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetListTrainingJobsLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetListTrainingJobsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetListTrainingJobsLogic {
+	return &GetListTrainingJobsLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// get ListTrainingJobs1
+func (l *GetListTrainingJobsLogic) GetListTrainingJobs(in *modelarts.ListTrainingJobsreq) (*modelarts.ListTrainingJobsresp, error) {
+	var resp modelarts.ListTrainingJobsresp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/training-job-searches"
+	reqByte, err := json.Marshal(in)
+	payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.POST, url, payload, token)
+	if err != nil {
+		return nil, err
+	}
+	jsonResult, err := simplejson.NewJson(body)
+	println(jsonResult)
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/gettokenlogic.go

@@ -0,0 +1,68 @@
+package logic
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"time"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type GetTokenLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewGetTokenLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetTokenLogic {
+	return &GetTokenLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// getToken
+func (l *GetTokenLogic) GetToken(in *modelarts.TokenReq) (*modelarts.TokenResp, error) {
+	// todo: add your logic here and delete this line
+
+	var resp modelarts.TokenResp
+	TokenUrl := "v3/auth/tokens"
+
+	jsonStr, _ := json.Marshal(in)
+	reqUrl, err := http.NewRequest("POST", "https://iam.cn-north-4.myhuaweicloud.com/"+TokenUrl, bytes.NewBuffer(jsonStr))
+
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer reqUrl.Body.Close()
+
+	c := http.Client{Timeout: time.Duration(3) * time.Second}
+
+	respUrl, err := c.Do(reqUrl)
+
+	print(respUrl)
+
+	defer respUrl.Body.Close()
+
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	result, _ := ioutil.ReadAll(respUrl.Body)
+	json.Unmarshal([]byte(string(result)), &resp)
+
+	//X-Auth-Token := respUrl.Header().Get("X-Subject-Token")
+
+	//return resp, nil
+
+	return &modelarts.TokenResp{}, nil
+
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listalgorithmslogic.go

@@ -0,0 +1,52 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"github.com/bitly/go-simplejson"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strconv"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListAlgorithmsLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListAlgorithmsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListAlgorithmsLogic {
+	return &ListAlgorithmsLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// ListAlgorithms 查询算法
+func (l *ListAlgorithmsLogic) ListAlgorithms(in *modelarts.ListAlgorithmsReq) (*modelarts.ListAlgorithmsResp, error) {
+	var resp modelarts.ListAlgorithmsResp
+	offset := strconv.Itoa(int(in.Offset))
+	limit := strconv.Itoa(int(in.Limit))
+	sortBy := in.SortBy
+	order := in.Order
+	groupBy := in.GroupBy
+	searches := in.Searches
+	workspaceId := in.WorkspaceId
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v2/" + in.ProjectId + "/algorithms?" + offset + "&" + limit + "&" + sortBy + "&" + order + "&" + groupBy + "&" + searches + "&" + workspaceId
+	//reqByte, err := json.Marshal(in)
+	//payload := strings.NewReader(string(reqByte))
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	jsonResult, err := simplejson.NewJson(body)
+	println(jsonResult)
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listclusterslogic.go

@@ -0,0 +1,46 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListClustersLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListClustersLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListClustersLogic {
+	return &ListClustersLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ListClustersLogic) ListClusters(in *modelarts.ListClustersReq) (*modelarts.ListClustersResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ListClustersResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/clusters"
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	//	var resp Pppp
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listmodelslogic.go

@@ -0,0 +1,45 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListModelsLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListModelsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListModelsLogic {
+	return &ListModelsLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ListModelsLogic) ListModels(in *modelarts.ListModelReq) (*modelarts.ListModelResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ListModelResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/models"
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listserviceslogic.go

@@ -0,0 +1,45 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ListServicesLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListServicesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListServicesLogic {
+	return &ListServicesLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ListServicesLogic) ListServices(in *modelarts.ListServicesReq) (*modelarts.ListServicesResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ListServicesResp
+
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/services"
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/listtrainingjobconfiglogic.go

@@ -0,0 +1,44 @@
+package logic
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"github.com/bitly/go-simplejson"
+	"github.com/zeromicro/go-zero/core/logx"
+	"k8s.io/apimachinery/pkg/util/json"
+	"strconv"
+)
+
+type ListTrainingJobConfigLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewListTrainingJobConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListTrainingJobConfigLogic {
+	return &ListTrainingJobConfigLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+// ListTrainingJobConfig 查询训练作业参数
+func (l *ListTrainingJobConfigLogic) ListTrainingJobConfig(in *modelarts.ListTrainingJobConfigReq) (*modelarts.ListTrainingJobConfigResp, error) {
+	var resp modelarts.ListTrainingJobConfigResp
+	perPage := strconv.Itoa(int(in.PerPage))
+	page := strconv.Itoa(int(in.Page))
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/training-job-configs?" + perPage + "&" + page
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	jsonResult, err := simplejson.NewJson(body)
+	println(&jsonResult)
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/showmodelslogic.go

@@ -0,0 +1,44 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ShowModelsLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewShowModelsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShowModelsLogic {
+	return &ShowModelsLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ShowModelsLogic) ShowModels(in *modelarts.ShowModelReq) (*modelarts.ShowModelResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ShowModelResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/models/" + in.ModelId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/logic/showservicelogic.go

@@ -0,0 +1,44 @@
+package logic
+
+/*
+	desc: "AI core微服务"
+	author: "xie"
+*/
+
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/common"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+	"PCM/common/tool"
+	"context"
+	"k8s.io/apimachinery/pkg/util/json"
+
+	"github.com/zeromicro/go-zero/core/logx"
+)
+
+type ShowServiceLogic struct {
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+	logx.Logger
+}
+
+func NewShowServiceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ShowServiceLogic {
+	return &ShowServiceLogic{
+		ctx:    ctx,
+		svcCtx: svcCtx,
+		Logger: logx.WithContext(ctx),
+	}
+}
+
+func (l *ShowServiceLogic) ShowService(in *modelarts.ShowServiceReq) (*modelarts.ShowServiceResp, error) {
+	// todo: add your logic here and delete this line
+	var resp modelarts.ShowServiceResp
+	url := "https://modelarts.cn-north-4.myhuaweicloud.com/v1/" + in.ProjectId + "/services/" + in.ServiceId
+	token := common.GetToken()
+	body, err := tool.HttpClient(tool.GET, url, nil, token)
+	if err != nil {
+		return nil, err
+	}
+	json.Unmarshal(body, &resp)
+	return &resp, nil
+}

adaptor/AIComputing/modelarts/rpc/internal/server/modelartsserver.go

@@ -0,0 +1,200 @@
+// Code generated by goctl. DO NOT EDIT.
+// Source: modelarts.proto
+
+package server
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/logic"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+)
+
+type ModelArtsServer struct {
+	svcCtx *svc.ServiceContext
+	modelarts.UnimplementedModelArtsServer
+}
+
+func NewModelArtsServer(svcCtx *svc.ServiceContext) *ModelArtsServer {
+	return &ModelArtsServer{
+		svcCtx: svcCtx,
+	}
+}
+
+// get modelarts Token
+func (s *ModelArtsServer) GetToken(ctx context.Context, in *modelarts.TokenReq) (*modelarts.TokenResp, error) {
+	l := logic.NewGetTokenLogic(ctx, s.svcCtx)
+	return l.GetToken(in)
+}
+
+// get modelarts Token
+func (s *ModelArtsServer) GetDatasetList(ctx context.Context, in *modelarts.DatasetReq) (*modelarts.DatasetResp, error) {
+	l := logic.NewGetDatasetListLogic(ctx, s.svcCtx)
+	return l.GetDatasetList(in)
+}
+
+// creat task  创建导入任务
+func (s *ModelArtsServer) CreateTask(ctx context.Context, in *modelarts.ImportTaskDataReq) (*modelarts.ImportTaskDataResp, error) {
+	l := logic.NewCreateTaskLogic(ctx, s.svcCtx)
+	return l.CreateTask(in)
+}
+
+// get taskList 查询数据集导入任务列表
+func (s *ModelArtsServer) GetImportTaskList(ctx context.Context, in *modelarts.ListImportTasksReq) (*modelarts.ListImportTasksResp, error) {
+	l := logic.NewGetImportTaskListLogic(ctx, s.svcCtx)
+	return l.GetImportTaskList(in)
+}
+
+// ListTrainingJobs 查询训练作业列表
+func (s *ModelArtsServer) GetListTrainingJobs(ctx context.Context, in *modelarts.ListTrainingJobsreq) (*modelarts.ListTrainingJobsresp, error) {
+	l := logic.NewGetListTrainingJobsLogic(ctx, s.svcCtx)
+	return l.GetListTrainingJobs(in)
+}
+
+// CreateTrainingJob 创建训练作业
+func (s *ModelArtsServer) CreateTrainingJob(ctx context.Context, in *modelarts.CreateTrainingJobReq) (*modelarts.CreateTrainingJobResp, error) {
+	l := logic.NewCreateTrainingJobLogic(ctx, s.svcCtx)
+	return l.CreateTrainingJob(in)
+}
+
+// DeleteTrainingJobConfig 删除训练作业
+func (s *ModelArtsServer) DeleteTrainingJob(ctx context.Context, in *modelarts.DeleteTrainingJobReq) (*modelarts.DeleteTrainingJobResp, error) {
+	l := logic.NewDeleteTrainingJobLogic(ctx, s.svcCtx)
+	return l.DeleteTrainingJob(in)
+}
+
+// CreateTrainingJobConfig 创建训练作业参数
+func (s *ModelArtsServer) CreateTrainingJobConfig(ctx context.Context, in *modelarts.CreateTrainingJobConfigReq) (*modelarts.CreateTrainingJobConfigResp, error) {
+	l := logic.NewCreateTrainingJobConfigLogic(ctx, s.svcCtx)
+	return l.CreateTrainingJobConfig(in)
+}
+
+// DeleteTrainingJobConfig 删除训练作业参数
+func (s *ModelArtsServer) DeleteTrainingJobConfig(ctx context.Context, in *modelarts.DeleteTrainingJobConfigReq) (*modelarts.DeleteTrainingJobConfigResp, error) {
+	l := logic.NewDeleteTrainingJobConfigLogic(ctx, s.svcCtx)
+	return l.DeleteTrainingJobConfig(in)
+}
+
+// ListTrainingJobConfig 查询训练作业参数
+func (s *ModelArtsServer) ListTrainingJobConfig(ctx context.Context, in *modelarts.ListTrainingJobConfigReq) (*modelarts.ListTrainingJobConfigResp, error) {
+	l := logic.NewListTrainingJobConfigLogic(ctx, s.svcCtx)
+	return l.ListTrainingJobConfig(in)
+}
+
+// CreateAlgorithm 创建算法
+func (s *ModelArtsServer) CreateAlgorithm(ctx context.Context, in *modelarts.CreateAlgorithmReq) (*modelarts.CreateAlgorithmResp, error) {
+	l := logic.NewCreateAlgorithmLogic(ctx, s.svcCtx)
+	return l.CreateAlgorithm(in)
+}
+
+// ListAlgorithms 查询算法
+func (s *ModelArtsServer) ListAlgorithms(ctx context.Context, in *modelarts.ListAlgorithmsReq) (*modelarts.ListAlgorithmsResp, error) {
+	l := logic.NewListAlgorithmsLogic(ctx, s.svcCtx)
+	return l.ListAlgorithms(in)
+}
+
+// export task
+func (s *ModelArtsServer) ExportTask(ctx context.Context, in *modelarts.ExportTaskReq) (*modelarts.ExportTaskResp, error) {
+	l := logic.NewExportTaskLogic(ctx, s.svcCtx)
+	return l.ExportTask(in)
+}
+
+func (s *ModelArtsServer) GetExportTasksOfDataset(ctx context.Context, in *modelarts.GetExportTasksOfDatasetReq) (*modelarts.GetExportTasksOfDatasetResp, error) {
+	l := logic.NewGetExportTasksOfDatasetLogic(ctx, s.svcCtx)
+	return l.GetExportTasksOfDataset(in)
+}
+
+func (s *ModelArtsServer) GetExportTaskStatusOfDataset(ctx context.Context, in *modelarts.GetExportTaskStatusOfDatasetReq) (*modelarts.GetExportTaskStatusOfDatasetResp, error) {
+	l := logic.NewGetExportTaskStatusOfDatasetLogic(ctx, s.svcCtx)
+	return l.GetExportTaskStatusOfDataset(in)
+}
+
+// processor task
+func (s *ModelArtsServer) CreateProcessorTask(ctx context.Context, in *modelarts.CreateProcessorTaskReq) (*modelarts.CreateProcessorTaskResp, error) {
+	l := logic.NewCreateProcessorTaskLogic(ctx, s.svcCtx)
+	return l.CreateProcessorTask(in)
+}
+
+func (s *ModelArtsServer) DescribeProcessorTask(ctx context.Context, in *modelarts.DescribeProcessorTaskReq) (*modelarts.DescribeProcessorTaskResp, error) {
+	l := logic.NewDescribeProcessorTaskLogic(ctx, s.svcCtx)
+	return l.DescribeProcessorTask(in)
+}
+
+// model management
+func (s *ModelArtsServer) CreateModel(ctx context.Context, in *modelarts.CreateModelReq) (*modelarts.CreateModelResp, error) {
+	l := logic.NewCreateModelLogic(ctx, s.svcCtx)
+	return l.CreateModel(in)
+}
+
+func (s *ModelArtsServer) DeleteModel(ctx context.Context, in *modelarts.DeleteModelReq) (*modelarts.DeleteModelResp, error) {
+	l := logic.NewDeleteModelLogic(ctx, s.svcCtx)
+	return l.DeleteModel(in)
+}
+
+func (s *ModelArtsServer) ListModels(ctx context.Context, in *modelarts.ListModelReq) (*modelarts.ListModelResp, error) {
+	l := logic.NewListModelsLogic(ctx, s.svcCtx)
+	return l.ListModels(in)
+}
+
+func (s *ModelArtsServer) ShowModels(ctx context.Context, in *modelarts.ShowModelReq) (*modelarts.ShowModelResp, error) {
+	l := logic.NewShowModelsLogic(ctx, s.svcCtx)
+	return l.ShowModels(in)
+}
+
+// service management
+func (s *ModelArtsServer) CreateService(ctx context.Context, in *modelarts.CreateServiceReq) (*modelarts.CreateServiceResp, error) {
+	l := logic.NewCreateServiceLogic(ctx, s.svcCtx)
+	return l.CreateService(in)
+}
+
+func (s *ModelArtsServer) ListServices(ctx context.Context, in *modelarts.ListServicesReq) (*modelarts.ListServicesResp, error) {
+	l := logic.NewListServicesLogic(ctx, s.svcCtx)
+	return l.ListServices(in)
+}
+
+func (s *ModelArtsServer) ShowService(ctx context.Context, in *modelarts.ShowServiceReq) (*modelarts.ShowServiceResp, error) {
+	l := logic.NewShowServiceLogic(ctx, s.svcCtx)
+	return l.ShowService(in)
+}
+
+func (s *ModelArtsServer) DeleteService(ctx context.Context, in *modelarts.DeleteServiceReq) (*modelarts.DeleteServiceResp, error) {
+	l := logic.NewDeleteServiceLogic(ctx, s.svcCtx)
+	return l.DeleteService(in)
+}
+
+func (s *ModelArtsServer) ListClusters(ctx context.Context, in *modelarts.ListClustersReq) (*modelarts.ListClustersResp, error) {
+	l := logic.NewListClustersLogic(ctx, s.svcCtx)
+	return l.ListClusters(in)
+}
+
+// notebook task
+func (s *ModelArtsServer) ListNotebook(ctx context.Context, in *modelarts.ListNotebookReq) (*modelarts.ListNotebookResp, error) {
+	l := logic.NewListNotebookLogic(ctx, s.svcCtx)
+	return l.ListNotebook(in)
+}
+
+func (s *ModelArtsServer) CreateNotebook(ctx context.Context, in *modelarts.CreateNotebookReq) (*modelarts.CreateNotebookResp, error) {
+	l := logic.NewCreateNotebookLogic(ctx, s.svcCtx)
+	return l.CreateNotebook(in)
+}
+
+func (s *ModelArtsServer) StartNotebook(ctx context.Context, in *modelarts.StartNotebookReq) (*modelarts.StartNotebookResp, error) {
+	l := logic.NewStartNotebookLogic(ctx, s.svcCtx)
+	return l.StartNotebook(in)
+}
+
+func (s *ModelArtsServer) StopNotebook(ctx context.Context, in *modelarts.StopNotebookReq) (*modelarts.StopNotebookResp, error) {
+	l := logic.NewStopNotebookLogic(ctx, s.svcCtx)
+	return l.StopNotebook(in)
+}
+
+func (s *ModelArtsServer) GetNotebookStorage(ctx context.Context, in *modelarts.GetNotebookStorageReq) (*modelarts.GetNotebookStorageResp, error) {
+	l := logic.NewGetNotebookStorageLogic(ctx, s.svcCtx)
+	return l.GetNotebookStorage(in)
+}
+
+func (s *ModelArtsServer) MountNotebookStorage(ctx context.Context, in *modelarts.MountNotebookStorageReq) (*modelarts.MountNotebookStorageResp, error) {
+	l := logic.NewMountNotebookStorageLogic(ctx, s.svcCtx)
+	return l.MountNotebookStorage(in)
+}

adaptor/AIComputing/modelarts/rpc/internal/svc/servicecontext.go

@@ -1,6 +1,8 @@
 package svc
 
-import "PCM/adaptor/slurm/slurmTianhe/rpc/internal/config"
+import (
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/config"
+)
 
 type ServiceContext struct {
 	Config config.Config

adaptor/AIComputing/modelarts/rpc/modelarts.go

@@ -4,10 +4,10 @@ import (
 	"flag"
 	"fmt"
 
-	"PCM/adaptor/slurm/slurmTianhe/rpc/internal/config"
-	"PCM/adaptor/slurm/slurmTianhe/rpc/internal/server"
-	"PCM/adaptor/slurm/slurmTianhe/rpc/internal/svc"
-	"PCM/adaptor/slurm/slurmTianhe/rpc/slurmTianhe"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/config"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/server"
+	"PCM/adaptor/AIComputing/modelarts/rpc/internal/svc"
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
 
 	"github.com/zeromicro/go-zero/core/conf"
 	"github.com/zeromicro/go-zero/core/service"
@@ -16,7 +16,7 @@ import (
 	"google.golang.org/grpc/reflection"
 )
 
-var configFile = flag.String("f", "adaptor/slurm/slurmTianhe/rpc/etc/slurmtianhe.yaml", "the config file")
+var configFile = flag.String("f", "adaptor/AIComputing/modelarts/rpc/etc/modelarts.yaml", "the config file")
 
 func main() {
 	flag.Parse()
@@ -26,7 +26,7 @@ func main() {
 	ctx := svc.NewServiceContext(c)
 
 	s := zrpc.MustNewServer(c.RpcServerConf, func(grpcServer *grpc.Server) {
-		slurmTianhe.RegisterSlurmTianheServer(grpcServer, server.NewSlurmTianheServer(ctx))
+		modelarts.RegisterModelArtsServer(grpcServer, server.NewModelArtsServer(ctx))
 
 		if c.Mode == service.DevMode || c.Mode == service.TestMode {
 			reflection.Register(grpcServer)

adaptor/AIComputing/modelarts/rpc/modelartsclient/modelarts.go

@@ -0,0 +1,462 @@
+// Code generated by goctl. DO NOT EDIT.
+// Source: modelarts.proto
+
+package modelartsclient
+
+import (
+	"context"
+
+	"PCM/adaptor/AIComputing/modelarts/rpc/modelarts"
+
+	"github.com/zeromicro/go-zero/zrpc"
+	"google.golang.org/grpc"
+)
+
+type (
+	AdvancedConfigAl                 = modelarts.AdvancedConfigAl
+	AlgoConfigs                      = modelarts.AlgoConfigs
+	Algorithm                        = modelarts.Algorithm
+	AlgorithmResponse                = modelarts.AlgorithmResponse
+	Algorithms                       = modelarts.Algorithms
+	AnnotationFormatConfig           = modelarts.AnnotationFormatConfig
+	AnnotationsS                     = modelarts.AnnotationsS
+	AttributesAlRq                   = modelarts.AttributesAlRq
+	Auth                             = modelarts.Auth
+	AutoSearch                       = modelarts.AutoSearch
+	AutoSearchAlgoConfigParameter    = modelarts.AutoSearchAlgoConfigParameter
+	Billing                          = modelarts.Billing
+	Children                         = modelarts.Children
+	Cluster                          = modelarts.Cluster
+	ClusterNode                      = modelarts.ClusterNode
+	CodeTree                         = modelarts.CodeTree
+	Config                           = modelarts.Config
+	ConfigResponse                   = modelarts.ConfigResponse
+	Constraint                       = modelarts.Constraint
+	ConstraintAlRp                   = modelarts.ConstraintAlRp
+	ConstraintAlRq                   = modelarts.ConstraintAlRq
+	ConstraintS                      = modelarts.ConstraintS
+	ContainerHooks                   = modelarts.ContainerHooks
+	Cpu                              = modelarts.Cpu
+	CreateAlgorithmReq               = modelarts.CreateAlgorithmReq
+	CreateAlgorithmResp              = modelarts.CreateAlgorithmResp
+	CreateDataSetReq                 = modelarts.CreateDataSetReq
+	CreateDataSetResq                = modelarts.CreateDataSetResq
+	CreateModelReq                   = modelarts.CreateModelReq
+	CreateModelRequestInferParams    = modelarts.CreateModelRequestInferParams
+	CreateModelRequestModelApis      = modelarts.CreateModelRequestModelApis
+	CreateModelRequestTemplateInput  = modelarts.CreateModelRequestTemplateInput
+	CreateModelResp                  = modelarts.CreateModelResp
+	CreateNotebookParam              = modelarts.CreateNotebookParam
+	CreateNotebookReq                = modelarts.CreateNotebookReq
+	CreateNotebookResp               = modelarts.CreateNotebookResp
+	CreateProcessorTaskReq           = modelarts.CreateProcessorTaskReq
+	CreateProcessorTaskResp          = modelarts.CreateProcessorTaskResp
+	CreateServiceReq                 = modelarts.CreateServiceReq
+	CreateServiceResp                = modelarts.CreateServiceResp
+	CreateTrainingJobConfigReq       = modelarts.CreateTrainingJobConfigReq
+	CreateTrainingJobConfigResp      = modelarts.CreateTrainingJobConfigResp
+	CreateTrainingJobReq             = modelarts.CreateTrainingJobReq
+	CreateTrainingJobResp            = modelarts.CreateTrainingJobResp
+	CustomHooks                      = modelarts.CustomHooks
+	CustomSpec                       = modelarts.CustomSpec
+	DataSource                       = modelarts.DataSource
+	DataSources                      = modelarts.DataSources
+	DataVolumesRes                   = modelarts.DataVolumesRes
+	Dataset                          = modelarts.Dataset
+	DatasetReq                       = modelarts.DatasetReq
+	DatasetResp                      = modelarts.DatasetResp
+	Datasets                         = modelarts.Datasets
+	DeleteModelReq                   = modelarts.DeleteModelReq
+	DeleteModelResp                  = modelarts.DeleteModelResp
+	DeleteModelResponseFailedList    = modelarts.DeleteModelResponseFailedList
+	DeleteServiceReq                 = modelarts.DeleteServiceReq
+	DeleteServiceResp                = modelarts.DeleteServiceResp
+	DeleteTrainingJobConfigReq       = modelarts.DeleteTrainingJobConfigReq
+	DeleteTrainingJobConfigResp      = modelarts.DeleteTrainingJobConfigResp
+	DeleteTrainingJobReq             = modelarts.DeleteTrainingJobReq
+	DeleteTrainingJobResp            = modelarts.DeleteTrainingJobResp
+	DescribeProcessorTaskReq         = modelarts.DescribeProcessorTaskReq
+	DescribeProcessorTaskResp        = modelarts.DescribeProcessorTaskResp
+	Disk                             = modelarts.Disk
+	Domain                           = modelarts.Domain
+	EndpointsReq                     = modelarts.EndpointsReq
+	EndpointsRes                     = modelarts.EndpointsRes
+	Engine                           = modelarts.Engine
+	EngineAlRp                       = modelarts.EngineAlRp
+	EngineAlRq                       = modelarts.EngineAlRq
+	Engines                          = modelarts.Engines
+	ExportParams                     = modelarts.ExportParams
+	ExportTaskReq                    = modelarts.ExportTaskReq
+	ExportTaskResp                   = modelarts.ExportTaskResp
+	ExportTaskStatus                 = modelarts.ExportTaskStatus
+	FileStatistics                   = modelarts.FileStatistics
+	FlavorDetail                     = modelarts.FlavorDetail
+	FlavorInfo                       = modelarts.FlavorInfo
+	FlavorResponse                   = modelarts.FlavorResponse
+	GetExportTaskStatusOfDatasetReq  = modelarts.GetExportTaskStatusOfDatasetReq
+	GetExportTaskStatusOfDatasetResp = modelarts.GetExportTaskStatusOfDatasetResp
+	GetExportTasksOfDatasetReq       = modelarts.GetExportTasksOfDatasetReq
+	GetExportTasksOfDatasetResp      = modelarts.GetExportTasksOfDatasetResp
+	GetNotebookStorageReq            = modelarts.GetNotebookStorageReq
+	GetNotebookStorageResp           = modelarts.GetNotebookStorageResp
+	Gpu                              = modelarts.Gpu
+	GuideDoc                         = modelarts.GuideDoc
+	I18NDescription                  = modelarts.I18NDescription
+	Identity                         = modelarts.Identity
+	Image                            = modelarts.Image
+	ImageInfo                        = modelarts.ImageInfo
+	ImportTaskDataReq                = modelarts.ImportTaskDataReq
+	ImportTaskDataResp               = modelarts.ImportTaskDataResp
+	ImportTasks                      = modelarts.ImportTasks
+	Input                            = modelarts.Input
+	InputDataInfo                    = modelarts.InputDataInfo
+	Inputs                           = modelarts.Inputs
+	InputsAlRp                       = modelarts.InputsAlRp
+	InputsAlRq                       = modelarts.InputsAlRq
+	JobAlgorithmResponse             = modelarts.JobAlgorithmResponse
+	JobConfigAl                      = modelarts.JobConfigAl
+	JobMetadata                      = modelarts.JobMetadata
+	JobProgress                      = modelarts.JobProgress
+	JobResponse                      = modelarts.JobResponse
+	Lease                            = modelarts.Lease
+	LeaseReq                         = modelarts.LeaseReq
+	ListAlgorithmsReq                = modelarts.ListAlgorithmsReq
+	ListAlgorithmsResp               = modelarts.ListAlgorithmsResp
+	ListClustersReq                  = modelarts.ListClustersReq
+	ListClustersResp                 = modelarts.ListClustersResp
+	ListImportTasksReq               = modelarts.ListImportTasksReq
+	ListImportTasksResp              = modelarts.ListImportTasksResp
+	ListModelReq                     = modelarts.ListModelReq
+	ListModelResp                    = modelarts.ListModelResp
+	ListNotebookParam                = modelarts.ListNotebookParam
+	ListNotebookReq                  = modelarts.ListNotebookReq
+	ListNotebookResp                 = modelarts.ListNotebookResp
+	ListServices                     = modelarts.ListServices
+	ListServicesReq                  = modelarts.ListServicesReq
+	ListServicesResp                 = modelarts.ListServicesResp
+	ListTrainingJobConfigReq         = modelarts.ListTrainingJobConfigReq
+	ListTrainingJobConfigResp        = modelarts.ListTrainingJobConfigResp
+	ListTrainingJobsreq              = modelarts.ListTrainingJobsreq
+	ListTrainingJobsresp             = modelarts.ListTrainingJobsresp
+	LogExportPath                    = modelarts.LogExportPath
+	Memory                           = modelarts.Memory
+	Metadata                         = modelarts.Metadata
+	MetadataAlRp                     = modelarts.MetadataAlRp
+	MetadataAlRq                     = modelarts.MetadataAlRq
+	MetadataS                        = modelarts.MetadataS
+	Methods                          = modelarts.Methods
+	ModelDependencies                = modelarts.ModelDependencies
+	ModelHealth                      = modelarts.ModelHealth
+	ModelInOutputParams              = modelarts.ModelInOutputParams
+	ModelListItem                    = modelarts.ModelListItem
+	ModelParamsInfo                  = modelarts.ModelParamsInfo
+	ModelSpecification               = modelarts.ModelSpecification
+	MountNotebookStorageParam        = modelarts.MountNotebookStorageParam
+	MountNotebookStorageReq          = modelarts.MountNotebookStorageReq
+	MountNotebookStorageResp         = modelarts.MountNotebookStorageResp
+	Nfs                              = modelarts.Nfs
+	NotebookResp                     = modelarts.NotebookResp
+	Npu                              = modelarts.Npu
+	Obs                              = modelarts.Obs
+	Obs1                             = modelarts.Obs1
+	OperatorParam                    = modelarts.OperatorParam
+	Output                           = modelarts.Output
+	Outputs                          = modelarts.Outputs
+	OutputsAl                        = modelarts.OutputsAl
+	OutputsAlRp                      = modelarts.OutputsAlRp
+	Packages                         = modelarts.Packages
+	Parameter                        = modelarts.Parameter
+	ParameterS                       = modelarts.ParameterS
+	Parameters                       = modelarts.Parameters
+	ParametersAlRp                   = modelarts.ParametersAlRp
+	ParametersAlRq                   = modelarts.ParametersAlRq
+	Password                         = modelarts.Password
+	Policies                         = modelarts.Policies
+	Pool                             = modelarts.Pool
+	ProcessorDataSource              = modelarts.ProcessorDataSource
+	Project                          = modelarts.Project
+	QueryServiceConfig               = modelarts.QueryServiceConfig
+	Remote                           = modelarts.Remote
+	RemoteConstraint                 = modelarts.RemoteConstraint
+	RemoteConstraints                = modelarts.RemoteConstraints
+	Resource                         = modelarts.Resource
+	ResourceRequirements             = modelarts.ResourceRequirements
+	ResourceS                        = modelarts.ResourceS
+	RewardAttrs                      = modelarts.RewardAttrs
+	Scheduler                        = modelarts.Scheduler
+	SchemaMaps                       = modelarts.SchemaMaps
+	Scope                            = modelarts.Scope
+	SearchCondition                  = modelarts.SearchCondition
+	SearchLabel                      = modelarts.SearchLabel
+	SearchLabels                     = modelarts.SearchLabels
+	SearchParams                     = modelarts.SearchParams
+	SearchProp                       = modelarts.SearchProp
+	ServiceConfig                    = modelarts.ServiceConfig
+	ShareInfoAlRp                    = modelarts.ShareInfoAlRp
+	ShowModelReq                     = modelarts.ShowModelReq
+	ShowModelResp                    = modelarts.ShowModelResp
+	ShowServiceReq                   = modelarts.ShowServiceReq
+	ShowServiceResp                  = modelarts.ShowServiceResp
+	SourceInfo                       = modelarts.SourceInfo
+	Spec                             = modelarts.Spec
+	Spec1                            = modelarts.Spec1
+	StartNotebookParam               = modelarts.StartNotebookParam
+	StartNotebookReq                 = modelarts.StartNotebookReq
+	StartNotebookResp                = modelarts.StartNotebookResp
+	Status                           = modelarts.Status
+	StopNotebookReq                  = modelarts.StopNotebookReq
+	StopNotebookResp                 = modelarts.StopNotebookResp
+	TagsAlRp                         = modelarts.TagsAlRp
+	TaskResponse                     = modelarts.TaskResponse
+	TaskStatuses                     = modelarts.TaskStatuses
+	Template                         = modelarts.Template
+	TemplateParam                    = modelarts.TemplateParam
+	TokenReq                         = modelarts.TokenReq
+	TokenResp                        = modelarts.TokenResp
+	TrainingExperimentReference      = modelarts.TrainingExperimentReference
+	User                             = modelarts.User
+	VolumeReq                        = modelarts.VolumeReq
+	VolumeRes                        = modelarts.VolumeRes
+	Volumes                          = modelarts.Volumes
+	Weigou                           = modelarts.Weigou
+	WorkPath                         = modelarts.WorkPath
+
+	ModelArts interface {
+		// get modelarts Token
+		GetToken(ctx context.Context, in *TokenReq, opts ...grpc.CallOption) (*TokenResp, error)
+		// get modelarts Token
+		GetDatasetList(ctx context.Context, in *DatasetReq, opts ...grpc.CallOption) (*DatasetResp, error)
+		// creat task  创建导入任务
+		CreateTask(ctx context.Context, in *ImportTaskDataReq, opts ...grpc.CallOption) (*ImportTaskDataResp, error)
+		// get taskList 查询数据集导入任务列表
+		GetImportTaskList(ctx context.Context, in *ListImportTasksReq, opts ...grpc.CallOption) (*ListImportTasksResp, error)
+		// ListTrainingJobs 查询训练作业列表
+		GetListTrainingJobs(ctx context.Context, in *ListTrainingJobsreq, opts ...grpc.CallOption) (*ListTrainingJobsresp, error)
+		// CreateTrainingJob 创建训练作业
+		CreateTrainingJob(ctx context.Context, in *CreateTrainingJobReq, opts ...grpc.CallOption) (*CreateTrainingJobResp, error)
+		// DeleteTrainingJobConfig 删除训练作业
+		DeleteTrainingJob(ctx context.Context, in *DeleteTrainingJobReq, opts ...grpc.CallOption) (*DeleteTrainingJobResp, error)
+		// CreateTrainingJobConfig 创建训练作业参数
+		CreateTrainingJobConfig(ctx context.Context, in *CreateTrainingJobConfigReq, opts ...grpc.CallOption) (*CreateTrainingJobConfigResp, error)
+		// DeleteTrainingJobConfig 删除训练作业参数
+		DeleteTrainingJobConfig(ctx context.Context, in *DeleteTrainingJobConfigReq, opts ...grpc.CallOption) (*DeleteTrainingJobConfigResp, error)
+		// ListTrainingJobConfig 查询训练作业参数
+		ListTrainingJobConfig(ctx context.Context, in *ListTrainingJobConfigReq, opts ...grpc.CallOption) (*ListTrainingJobConfigResp, error)
+		// CreateAlgorithm 创建算法
+		CreateAlgorithm(ctx context.Context, in *CreateAlgorithmReq, opts ...grpc.CallOption) (*CreateAlgorithmResp, error)
+		// ListAlgorithms 查询算法
+		ListAlgorithms(ctx context.Context, in *ListAlgorithmsReq, opts ...grpc.CallOption) (*ListAlgorithmsResp, error)
+		// export task
+		ExportTask(ctx context.Context, in *ExportTaskReq, opts ...grpc.CallOption) (*ExportTaskResp, error)
+		GetExportTasksOfDataset(ctx context.Context, in *GetExportTasksOfDatasetReq, opts ...grpc.CallOption) (*GetExportTasksOfDatasetResp, error)
+		GetExportTaskStatusOfDataset(ctx context.Context, in *GetExportTaskStatusOfDatasetReq, opts ...grpc.CallOption) (*GetExportTaskStatusOfDatasetResp, error)
+		// processor task
+		CreateProcessorTask(ctx context.Context, in *CreateProcessorTaskReq, opts ...grpc.CallOption) (*CreateProcessorTaskResp, error)
+		DescribeProcessorTask(ctx context.Context, in *DescribeProcessorTaskReq, opts ...grpc.CallOption) (*DescribeProcessorTaskResp, error)
+		// model management
+		CreateModel(ctx context.Context, in *CreateModelReq, opts ...grpc.CallOption) (*CreateModelResp, error)
+		DeleteModel(ctx context.Context, in *DeleteModelReq, opts ...grpc.CallOption) (*DeleteModelResp, error)
+		ListModels(ctx context.Context, in *ListModelReq, opts ...grpc.CallOption) (*ListModelResp, error)
+		ShowModels(ctx context.Context, in *ShowModelReq, opts ...grpc.CallOption) (*ShowModelResp, error)
+		// service management
+		CreateService(ctx context.Context, in *CreateServiceReq, opts ...grpc.CallOption) (*CreateServiceResp, error)
+		ListServices(ctx context.Context, in *ListServicesReq, opts ...grpc.CallOption) (*ListServicesResp, error)
+		ShowService(ctx context.Context, in *ShowServiceReq, opts ...grpc.CallOption) (*ShowServiceResp, error)
+		DeleteService(ctx context.Context, in *DeleteServiceReq, opts ...grpc.CallOption) (*DeleteServiceResp, error)
+		ListClusters(ctx context.Context, in *ListClustersReq, opts ...grpc.CallOption) (*ListClustersResp, error)
+		// notebook task
+		ListNotebook(ctx context.Context, in *ListNotebookReq, opts ...grpc.CallOption) (*ListNotebookResp, error)
+		CreateNotebook(ctx context.Context, in *CreateNotebookReq, opts ...grpc.CallOption) (*CreateNotebookResp, error)
+		StartNotebook(ctx context.Context, in *StartNotebookReq, opts ...grpc.CallOption) (*StartNotebookResp, error)
+		StopNotebook(ctx context.Context, in *StopNotebookReq, opts ...grpc.CallOption) (*StopNotebookResp, error)
+		GetNotebookStorage(ctx context.Context, in *GetNotebookStorageReq, opts ...grpc.CallOption) (*GetNotebookStorageResp, error)
+		MountNotebookStorage(ctx context.Context, in *MountNotebookStorageReq, opts ...grpc.CallOption) (*MountNotebookStorageResp, error)
+	}
+
+	defaultModelArts struct {
+		cli zrpc.Client
+	}
+)
+
+func NewModelArts(cli zrpc.Client) ModelArts {
+	return &defaultModelArts{
+		cli: cli,
+	}
+}
+
+// get modelarts Token
+func (m *defaultModelArts) GetToken(ctx context.Context, in *TokenReq, opts ...grpc.CallOption) (*TokenResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.GetToken(ctx, in, opts...)
+}
+
+// get modelarts Token
+func (m *defaultModelArts) GetDatasetList(ctx context.Context, in *DatasetReq, opts ...grpc.CallOption) (*DatasetResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.GetDatasetList(ctx, in, opts...)
+}
+
+// creat task  创建导入任务
+func (m *defaultModelArts) CreateTask(ctx context.Context, in *ImportTaskDataReq, opts ...grpc.CallOption) (*ImportTaskDataResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.CreateTask(ctx, in, opts...)
+}
+
+// get taskList 查询数据集导入任务列表
+func (m *defaultModelArts) GetImportTaskList(ctx context.Context, in *ListImportTasksReq, opts ...grpc.CallOption) (*ListImportTasksResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.GetImportTaskList(ctx, in, opts...)
+}
+
+// ListTrainingJobs 查询训练作业列表
+func (m *defaultModelArts) GetListTrainingJobs(ctx context.Context, in *ListTrainingJobsreq, opts ...grpc.CallOption) (*ListTrainingJobsresp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.GetListTrainingJobs(ctx, in, opts...)
+}
+
+// CreateTrainingJob 创建训练作业
+func (m *defaultModelArts) CreateTrainingJob(ctx context.Context, in *CreateTrainingJobReq, opts ...grpc.CallOption) (*CreateTrainingJobResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.CreateTrainingJob(ctx, in, opts...)
+}
+
+// DeleteTrainingJobConfig 删除训练作业
+func (m *defaultModelArts) DeleteTrainingJob(ctx context.Context, in *DeleteTrainingJobReq, opts ...grpc.CallOption) (*DeleteTrainingJobResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.DeleteTrainingJob(ctx, in, opts...)
+}
+
+// CreateTrainingJobConfig 创建训练作业参数
+func (m *defaultModelArts) CreateTrainingJobConfig(ctx context.Context, in *CreateTrainingJobConfigReq, opts ...grpc.CallOption) (*CreateTrainingJobConfigResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.CreateTrainingJobConfig(ctx, in, opts...)
+}
+
+// DeleteTrainingJobConfig 删除训练作业参数
+func (m *defaultModelArts) DeleteTrainingJobConfig(ctx context.Context, in *DeleteTrainingJobConfigReq, opts ...grpc.CallOption) (*DeleteTrainingJobConfigResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.DeleteTrainingJobConfig(ctx, in, opts...)
+}
+
+// ListTrainingJobConfig 查询训练作业参数
+func (m *defaultModelArts) ListTrainingJobConfig(ctx context.Context, in *ListTrainingJobConfigReq, opts ...grpc.CallOption) (*ListTrainingJobConfigResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.ListTrainingJobConfig(ctx, in, opts...)
+}
+
+// CreateAlgorithm 创建算法
+func (m *defaultModelArts) CreateAlgorithm(ctx context.Context, in *CreateAlgorithmReq, opts ...grpc.CallOption) (*CreateAlgorithmResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.CreateAlgorithm(ctx, in, opts...)
+}
+
+// ListAlgorithms 查询算法
+func (m *defaultModelArts) ListAlgorithms(ctx context.Context, in *ListAlgorithmsReq, opts ...grpc.CallOption) (*ListAlgorithmsResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.ListAlgorithms(ctx, in, opts...)
+}
+
+// export task
+func (m *defaultModelArts) ExportTask(ctx context.Context, in *ExportTaskReq, opts ...grpc.CallOption) (*ExportTaskResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.ExportTask(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) GetExportTasksOfDataset(ctx context.Context, in *GetExportTasksOfDatasetReq, opts ...grpc.CallOption) (*GetExportTasksOfDatasetResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.GetExportTasksOfDataset(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) GetExportTaskStatusOfDataset(ctx context.Context, in *GetExportTaskStatusOfDatasetReq, opts ...grpc.CallOption) (*GetExportTaskStatusOfDatasetResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.GetExportTaskStatusOfDataset(ctx, in, opts...)
+}
+
+// processor task
+func (m *defaultModelArts) CreateProcessorTask(ctx context.Context, in *CreateProcessorTaskReq, opts ...grpc.CallOption) (*CreateProcessorTaskResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.CreateProcessorTask(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) DescribeProcessorTask(ctx context.Context, in *DescribeProcessorTaskReq, opts ...grpc.CallOption) (*DescribeProcessorTaskResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.DescribeProcessorTask(ctx, in, opts...)
+}
+
+// model management
+func (m *defaultModelArts) CreateModel(ctx context.Context, in *CreateModelReq, opts ...grpc.CallOption) (*CreateModelResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.CreateModel(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) DeleteModel(ctx context.Context, in *DeleteModelReq, opts ...grpc.CallOption) (*DeleteModelResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.DeleteModel(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) ListModels(ctx context.Context, in *ListModelReq, opts ...grpc.CallOption) (*ListModelResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.ListModels(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) ShowModels(ctx context.Context, in *ShowModelReq, opts ...grpc.CallOption) (*ShowModelResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.ShowModels(ctx, in, opts...)
+}
+
+// service management
+func (m *defaultModelArts) CreateService(ctx context.Context, in *CreateServiceReq, opts ...grpc.CallOption) (*CreateServiceResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.CreateService(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) ListServices(ctx context.Context, in *ListServicesReq, opts ...grpc.CallOption) (*ListServicesResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.ListServices(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) ShowService(ctx context.Context, in *ShowServiceReq, opts ...grpc.CallOption) (*ShowServiceResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.ShowService(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) DeleteService(ctx context.Context, in *DeleteServiceReq, opts ...grpc.CallOption) (*DeleteServiceResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.DeleteService(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) ListClusters(ctx context.Context, in *ListClustersReq, opts ...grpc.CallOption) (*ListClustersResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.ListClusters(ctx, in, opts...)
+}
+
+// notebook task
+func (m *defaultModelArts) ListNotebook(ctx context.Context, in *ListNotebookReq, opts ...grpc.CallOption) (*ListNotebookResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.ListNotebook(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) CreateNotebook(ctx context.Context, in *CreateNotebookReq, opts ...grpc.CallOption) (*CreateNotebookResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.CreateNotebook(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) StartNotebook(ctx context.Context, in *StartNotebookReq, opts ...grpc.CallOption) (*StartNotebookResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.StartNotebook(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) StopNotebook(ctx context.Context, in *StopNotebookReq, opts ...grpc.CallOption) (*StopNotebookResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.StopNotebook(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) GetNotebookStorage(ctx context.Context, in *GetNotebookStorageReq, opts ...grpc.CallOption) (*GetNotebookStorageResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.GetNotebookStorage(ctx, in, opts...)
+}
+
+func (m *defaultModelArts) MountNotebookStorage(ctx context.Context, in *MountNotebookStorageReq, opts ...grpc.CallOption) (*MountNotebookStorageResp, error) {
+	client := modelarts.NewModelArtsClient(m.cli.Conn())
+	return client.MountNotebookStorage(ctx, in, opts...)
+}

adaptor/slurm/slurmShuguang/rpc/internal/logic/listhistoryjoblogic.go

@@ -3,6 +3,7 @@ package logic
 import (
 	"PCM/adaptor/slurm/slurmShuguang/rpc/internal/util"
 	"context"
+	"github.com/bitly/go-simplejson"
 	"io"
 	"log"
 	"net/http"
@@ -12,7 +13,6 @@ import (
 
 	"PCM/adaptor/slurm/slurmShuguang/rpc/internal/svc"
 	"PCM/adaptor/slurm/slurmShuguang/rpc/slurmShuguang"
-	"github.com/bitly/go-simplejson"
 	"github.com/zeromicro/go-zero/core/logx"
 )
 
@@ -87,7 +87,6 @@ func (l *ListHistoryJobLogic) ListHistoryJob(in *slurmShuguang.ListHistoryJobReq
 	defer func(Body io.ReadCloser) {
 		err := Body.Close()
 		if err != nil {
-
 		}
 	}(respUrl.Body)
 

adaptor/slurm/slurmTianhe/rpc/etc/slurmtianhe.yaml

@@ -1,3 +0,0 @@
-Name: slurmtianhe.rpc
-ListenOn: 0.0.0.0:2002
-

adaptor/slurm/slurmTianhe/rpc/internal/logic/listhistoryjoblogic.go

@@ -1,155 +0,0 @@
-package logic
-
-/*
-#cgo LDFLAGS: -lslurmdb
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <slurm/slurm.h>
-#include <slurm/slurmdb.h>
-#include <slurm/slurm_errno.h>
-#include <memory.h>
-#include <malloc.h>
-
-slurmdb_job_rec_t *get_all_slurmdb_job() {
-
-    slurmdb_job_cond_t *job_cond = NULL;
-	void *conn = slurmdb_connection_get();
-
-	List joblist = slurmdb_jobs_get(conn, job_cond);
-
-	uint16_t listsize = slurm_list_count(joblist);
-	//qosinfo.record_count = size;
-	slurmdb_job_rec_t *jobarray = malloc(listsize * sizeof(slurmdb_job_rec_t));
-
-	ListIterator itr = slurm_list_iterator_create(joblist);
-
-    slurmdb_job_rec_t *rec = NULL;
-	int i = 0;
-	while ((rec = slurm_list_next(itr))) {
-  		jobarray[i] = *rec;
-  		i++;
-	}
-	slurmdb_connection_close(&conn);
-	slurm_list_destroy(joblist);
-	//int arraysize = sizeof(jobarray);
-	//printf("%d\n", arraysize);
-	return jobarray;
-}
-
-slurmdb_job_rec_t *job_from_array(slurmdb_job_rec_t *job_rec_array, int i) {
-  return (slurmdb_job_rec_t *) &(job_rec_array[i]);
-}
-
-slurmdb_job_rec_t *job_from_array_by_id(slurmdb_job_rec_t *job_rec_array, int job_id) {
-	int i;
-    int arraysize = sizeof(job_rec_array);
-    for (i=0; i<arraysize; i++)
-    {
-         //printf("var: %d : %p : %d \n", var, &(job_rec_array[var]), (job_rec_array[var]).stats.cpu_min);
-         //printf("%d \n",(job_rec_array[i]).stats.cpu_min);
-         //printf("var: %d : %p : %d \n", var, &(job_rec_array[var]), (job_rec_array[var]).jobid);
-         if (job_id==(job_rec_array[i]).jobid)
-         {
-			break;
-         } else {
-			return NULL;
-         }
-    }
-	return (slurmdb_job_rec_t *) &(job_rec_array[i]);
-
-}
-int getLength(slurmdb_job_rec_t *job_rec_array) {
-  return sizeof(job_rec_array);
-}
-
-*/
-import "C"
-
-import (
-	"context"
-
-	"PCM/adaptor/slurm/slurmTianhe/rpc/internal/svc"
-	"PCM/adaptor/slurm/slurmTianhe/rpc/slurmTianhe"
-
-	"github.com/zeromicro/go-zero/core/logx"
-)
-
-type ListHistoryJobLogic struct {
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-	logx.Logger
-}
-
-func NewListHistoryJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListHistoryJobLogic {
-	return &ListHistoryJobLogic{
-		ctx:    ctx,
-		svcCtx: svcCtx,
-		Logger: logx.WithContext(ctx),
-	}
-}
-
-// ListHistoryJob list all jobs from slurmdb
-func (l *ListHistoryJobLogic) ListHistoryJob(in *slurmTianhe.ListHistoryJobReq) (*slurmTianhe.ListHistoryJobResp, error) {
-
-	var dbJobResp slurmTianhe.ListHistoryJobResp
-	jobInfos := C.get_all_slurmdb_job()
-	size := uint32(C.getLength(jobInfos))
-	dbJobResp.RecordCount = size
-	for i := uint32(0); i < size; i++ {
-		cJob := C.job_from_array(jobInfos, C.int(i))
-		goJob := SlurmdbJobConvertCToGo(cJob)
-		dbJobResp.HistoryJobs = append(dbJobResp.HistoryJobs, &goJob)
-	}
-	dbJobResp.Code = 200
-	dbJobResp.Msg = "success"
-
-	return &dbJobResp, nil
-}
-
-func SlurmdbJobConvertCToGo(cStructJob *C.slurmdb_job_rec_t) slurmTianhe.HistoryJob {
-	var goStruct slurmTianhe.HistoryJob
-
-	goStruct.Account = C.GoString(cStructJob.account)
-	goStruct.Associd = uint32(cStructJob.associd)
-	goStruct.AllocCpu = uint32(cStructJob.alloc_cpus)
-	goStruct.AllocNodes = uint32(cStructJob.alloc_nodes)
-	goStruct.Blockid = C.GoString(cStructJob.blockid)
-	goStruct.Cluster = C.GoString(cStructJob.cluster)
-	goStruct.DerivedEs = C.GoString(cStructJob.derived_es)
-	goStruct.DerivedEc = uint32(cStructJob.derived_ec)
-	goStruct.End = int64(cStructJob.end)
-	goStruct.Elapsed = uint32(cStructJob.elapsed)
-	goStruct.Eligible = int64(cStructJob.eligible)
-	goStruct.Exitcode = uint32(cStructJob.exitcode)
-	goStruct.Gid = uint32(cStructJob.gid)
-	goStruct.Jobid = uint32(cStructJob.jobid)
-	goStruct.Jobname = C.GoString(cStructJob.jobname)
-	goStruct.Lft = uint32(cStructJob.lft)
-	goStruct.Nodes = C.GoString(cStructJob.nodes)
-	goStruct.Priority = uint32(cStructJob.priority)
-	goStruct.Partition = C.GoString(cStructJob.partition)
-	goStruct.Qosid = uint32(cStructJob.qosid)
-	goStruct.Resvid = uint32(cStructJob.resvid)
-	goStruct.Requid = uint32(cStructJob.requid)
-	goStruct.ReqCpus = uint32(cStructJob.req_cpus)
-	goStruct.ReqMem = uint32(cStructJob.req_mem)
-	goStruct.Start = int64(cStructJob.start)
-	goStruct.State = uint32(cStructJob.state)
-	goStruct.SysCpuUsec = uint32(cStructJob.sys_cpu_usec)
-	goStruct.SysCpuSec = uint32(cStructJob.sys_cpu_sec)
-	goStruct.Submit = int64(cStructJob.submit)
-	goStruct.Suspended = uint32(cStructJob.suspended)
-	goStruct.ShowFull = uint32(cStructJob.show_full)
-
-	//var stats_adrs []*pbslurm.SlurmdbStatsT
-	//var stats pbslurm.SlurmdbStatsT
-	//stat.ActCpufreq = float64(c_struct_job.stats.act_cpufreq)
-	//stats.CpuMin = uint32((c_struct_job.stats).cpu_min)
-	//stat.CpuAve = float64(c_struct_job.stats.cpu_ave)
-	//stats_adrs = append(stats_adrs, &stats)
-	//go_struct.Stats = stats
-
-	return goStruct
-}

adaptor/slurm/slurmTianhe/rpc/internal/logic/listjoblogic.go

@@ -1,31 +0,0 @@
-package logic
-
-import (
-	"context"
-
-	"PCM/adaptor/slurm/slurmTianhe/rpc/internal/svc"
-	"PCM/adaptor/slurm/slurmTianhe/rpc/slurmTianhe"
-
-	"github.com/zeromicro/go-zero/core/logx"
-)
-
-type ListJobLogic struct {
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-	logx.Logger
-}
-
-func NewListJobLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ListJobLogic {
-	return &ListJobLogic{
-		ctx:    ctx,
-		svcCtx: svcCtx,
-		Logger: logx.WithContext(ctx),
-	}
-}
-
-// ListJob list all jobs
-func (l *ListJobLogic) ListJob(in *slurmTianhe.ListJobReq) (*slurmTianhe.ListJobResp, error) {
-	// todo: add your logic here and delete this line
-
-	return &slurmTianhe.ListJobResp{}, nil
-}

adaptor/slurm/slurmTianhe/rpc/internal/server/slurmtianheserver.go

@@ -1,35 +0,0 @@
-// Code generated by goctl. DO NOT EDIT.
-// Source: slurmTianhe.proto
-
-package server
-
-import (
-	"context"
-
-	"PCM/adaptor/slurm/slurmTianhe/rpc/internal/logic"
-	"PCM/adaptor/slurm/slurmTianhe/rpc/internal/svc"
-	"PCM/adaptor/slurm/slurmTianhe/rpc/slurmTianhe"
-)
-
-type SlurmTianheServer struct {
-	svcCtx *svc.ServiceContext
-	slurmTianhe.UnimplementedSlurmTianheServer
-}
-
-func NewSlurmTianheServer(svcCtx *svc.ServiceContext) *SlurmTianheServer {
-	return &SlurmTianheServer{
-		svcCtx: svcCtx,
-	}
-}
-
-// ListJob list all jobs
-func (s *SlurmTianheServer) ListJob(ctx context.Context, in *slurmTianhe.ListJobReq) (*slurmTianhe.ListJobResp, error) {
-	l := logic.NewListJobLogic(ctx, s.svcCtx)
-	return l.ListJob(in)
-}
-
-// ListHistoryJob list all history jobs
-func (s *SlurmTianheServer) ListHistoryJob(ctx context.Context, in *slurmTianhe.ListHistoryJobReq) (*slurmTianhe.ListHistoryJobResp, error) {
-	l := logic.NewListHistoryJobLogic(ctx, s.svcCtx)
-	return l.ListHistoryJob(in)
-}

adaptor/slurm/slurmTianhe/rpc/slurmTianhe/slurmTianhe_grpc.pb.go

@@ -1,145 +0,0 @@
-// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
-// versions:
-// - protoc-gen-go-grpc v1.2.0
-// - protoc             v3.19.4
-// source: slurmTianhe.proto
-
-package slurmTianhe
-
-import (
-	context "context"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-)
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-// Requires gRPC-Go v1.32.0 or later.
-const _ = grpc.SupportPackageIsVersion7
-
-// SlurmTianheClient is the client API for SlurmTianhe service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
-type SlurmTianheClient interface {
-	// ListJob list all jobs
-	ListJob(ctx context.Context, in *ListJobReq, opts ...grpc.CallOption) (*ListJobResp, error)
-	// ListHistoryJob list all history jobs
-	ListHistoryJob(ctx context.Context, in *ListHistoryJobReq, opts ...grpc.CallOption) (*ListHistoryJobResp, error)
-}
-
-type slurmTianheClient struct {
-	cc grpc.ClientConnInterface
-}
-
-func NewSlurmTianheClient(cc grpc.ClientConnInterface) SlurmTianheClient {
-	return &slurmTianheClient{cc}
-}
-
-func (c *slurmTianheClient) ListJob(ctx context.Context, in *ListJobReq, opts ...grpc.CallOption) (*ListJobResp, error) {
-	out := new(ListJobResp)
-	err := c.cc.Invoke(ctx, "/slurmTianhe.slurmTianhe/ListJob", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *slurmTianheClient) ListHistoryJob(ctx context.Context, in *ListHistoryJobReq, opts ...grpc.CallOption) (*ListHistoryJobResp, error) {
-	out := new(ListHistoryJobResp)
-	err := c.cc.Invoke(ctx, "/slurmTianhe.slurmTianhe/ListHistoryJob", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// SlurmTianheServer is the server API for SlurmTianhe service.
-// All implementations must embed UnimplementedSlurmTianheServer
-// for forward compatibility
-type SlurmTianheServer interface {
-	// ListJob list all jobs
-	ListJob(context.Context, *ListJobReq) (*ListJobResp, error)
-	// ListHistoryJob list all history jobs
-	ListHistoryJob(context.Context, *ListHistoryJobReq) (*ListHistoryJobResp, error)
-	mustEmbedUnimplementedSlurmTianheServer()
-}
-
-// UnimplementedSlurmTianheServer must be embedded to have forward compatible implementations.
-type UnimplementedSlurmTianheServer struct {
-}
-
-func (UnimplementedSlurmTianheServer) ListJob(context.Context, *ListJobReq) (*ListJobResp, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListJob not implemented")
-}
-func (UnimplementedSlurmTianheServer) ListHistoryJob(context.Context, *ListHistoryJobReq) (*ListHistoryJobResp, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method ListHistoryJob not implemented")
-}
-func (UnimplementedSlurmTianheServer) mustEmbedUnimplementedSlurmTianheServer() {}
-
-// UnsafeSlurmTianheServer may be embedded to opt out of forward compatibility for this service.
-// Use of this interface is not recommended, as added methods to SlurmTianheServer will
-// result in compilation errors.
-type UnsafeSlurmTianheServer interface {
-	mustEmbedUnimplementedSlurmTianheServer()
-}
-
-func RegisterSlurmTianheServer(s grpc.ServiceRegistrar, srv SlurmTianheServer) {
-	s.RegisterService(&SlurmTianhe_ServiceDesc, srv)
-}
-
-func _SlurmTianhe_ListJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListJobReq)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(SlurmTianheServer).ListJob(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/slurmTianhe.slurmTianhe/ListJob",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(SlurmTianheServer).ListJob(ctx, req.(*ListJobReq))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _SlurmTianhe_ListHistoryJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(ListHistoryJobReq)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(SlurmTianheServer).ListHistoryJob(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/slurmTianhe.slurmTianhe/ListHistoryJob",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(SlurmTianheServer).ListHistoryJob(ctx, req.(*ListHistoryJobReq))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-// SlurmTianhe_ServiceDesc is the grpc.ServiceDesc for SlurmTianhe service.
-// It's only intended for direct use with grpc.RegisterService,
-// and not to be introspected or modified (even as a copy)
-var SlurmTianhe_ServiceDesc = grpc.ServiceDesc{
-	ServiceName: "slurmTianhe.slurmTianhe",
-	HandlerType: (*SlurmTianheServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "ListJob",
-			Handler:    _SlurmTianhe_ListJob_Handler,
-		},
-		{
-			MethodName: "ListHistoryJob",
-			Handler:    _SlurmTianhe_ListHistoryJob_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "slurmTianhe.proto",
-}

adaptor/slurm/slurmTianhe/rpc/slurmtianheclient/slurmtianhe.go

@@ -1,51 +0,0 @@
-// Code generated by goctl. DO NOT EDIT.
-// Source: slurmTianhe.proto
-
-package slurmtianheclient
-
-import (
-	"context"
-
-	"PCM/adaptor/slurm/slurmTianhe/rpc/slurmTianhe"
-
-	"github.com/zeromicro/go-zero/zrpc"
-	"google.golang.org/grpc"
-)
-
-type (
-	HistoryJob         = slurmTianhe.HistoryJob
-	Job                = slurmTianhe.Job
-	ListHistoryJobReq  = slurmTianhe.ListHistoryJobReq
-	ListHistoryJobResp = slurmTianhe.ListHistoryJobResp
-	ListJobReq         = slurmTianhe.ListJobReq
-	ListJobResp        = slurmTianhe.ListJobResp
-
-	SlurmTianhe interface {
-		// ListJob list all jobs
-		ListJob(ctx context.Context, in *ListJobReq, opts ...grpc.CallOption) (*ListJobResp, error)
-		// ListHistoryJob list all history jobs
-		ListHistoryJob(ctx context.Context, in *ListHistoryJobReq, opts ...grpc.CallOption) (*ListHistoryJobResp, error)
-	}
-
-	defaultSlurmTianhe struct {
-		cli zrpc.Client
-	}
-)
-
-func NewSlurmTianhe(cli zrpc.Client) SlurmTianhe {
-	return &defaultSlurmTianhe{
-		cli: cli,
-	}
-}
-
-// ListJob list all jobs
-func (m *defaultSlurmTianhe) ListJob(ctx context.Context, in *ListJobReq, opts ...grpc.CallOption) (*ListJobResp, error) {
-	client := slurmTianhe.NewSlurmTianheClient(m.cli.Conn())
-	return client.ListJob(ctx, in, opts...)
-}
-
-// ListHistoryJob list all history jobs
-func (m *defaultSlurmTianhe) ListHistoryJob(ctx context.Context, in *ListHistoryJobReq, opts ...grpc.CallOption) (*ListHistoryJobResp, error) {
-	client := slurmTianhe.NewSlurmTianheClient(m.cli.Conn())
-	return client.ListHistoryJob(ctx, in, opts...)
-}

common/tool/http.go

@@ -0,0 +1,33 @@
+package tool
+
+import (
+	"io"
+	"log"
+	"net/http"
+)
+
+const (
+	GET    = "GET"
+	PUT    = "PUT"
+	POST   = "POST"
+	DELETE = "DELETE"
+)
+
+func HttpClient(method string, url string, payload io.Reader, token string) ([]byte, error) {
+	request, err := http.NewRequest(method, url, payload)
+	request.Header.Add("Content-Type", "application/json")
+	request.Header.Add("User-Agent", "API Explorer")
+	request.Header.Add("x-auth-token", token)
+	client := &http.Client{}
+	res, err := client.Do(request)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer res.Body.Close()
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return body, err
+}

go.mod

@@ -4,20 +4,23 @@ go 1.19
 
 require (
 	github.com/bitly/go-simplejson v0.5.0
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0
 	github.com/jinzhu/copier v0.3.5
 	github.com/pkg/errors v0.9.1
 	github.com/shopspring/decimal v1.3.1
 	github.com/sony/sonyflake v1.1.0
 	github.com/zeromicro/go-zero v1.4.4
-	google.golang.org/grpc v1.50.1
+	google.golang.org/grpc v1.53.0
 	google.golang.org/protobuf v1.28.1
+	k8s.io/apimachinery v0.22.9
+	sigs.k8s.io/yaml v1.3.0
 )
 
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 // indirect
 	github.com/cenkalti/backoff/v4 v4.1.3 // indirect
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/coreos/go-semver v0.3.0 // indirect
 	github.com/coreos/go-systemd/v22 v22.3.2 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
@@ -36,7 +39,6 @@ require (
 	github.com/google/pprof v0.0.0-20211214055906-6f57359322fd // indirect
 	github.com/google/uuid v1.3.0 // indirect
 	github.com/googleapis/gnostic v0.5.5 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/mattn/go-colorable v0.1.9 // indirect
 	github.com/mattn/go-isatty v0.0.14 // indirect
@@ -67,22 +69,20 @@ require (
 	go.uber.org/automaxprocs v1.5.1 // indirect
 	go.uber.org/multierr v1.8.0 // indirect
 	go.uber.org/zap v1.21.0 // indirect
-	golang.org/x/net v0.0.0-20221014081412-f15817d10f9b // indirect
-	golang.org/x/oauth2 v0.0.0-20221014153046-6fdb5e3db783 // indirect
-	golang.org/x/sys v0.0.0-20220728004956-3c1f35247d10 // indirect
-	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
-	golang.org/x/text v0.4.0 // indirect
+	golang.org/x/net v0.5.0 // indirect
+	golang.org/x/oauth2 v0.4.0 // indirect
+	golang.org/x/sys v0.4.0 // indirect
+	golang.org/x/term v0.4.0 // indirect
+	golang.org/x/text v0.6.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20221111202108-142d8a6fa32e // indirect
+	google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	k8s.io/api v0.22.9 // indirect
-	k8s.io/apimachinery v0.22.9 // indirect
 	k8s.io/client-go v0.22.9 // indirect
 	k8s.io/klog/v2 v2.80.1 // indirect
 	k8s.io/utils v0.0.0-20221108210102-8e77b1f39fe2 // indirect
 	sigs.k8s.io/structured-merge-diff/v4 v4.2.1 // indirect
-	sigs.k8s.io/yaml v1.2.0 // indirect
 )