From 9ef831fdbb92e7795d20445c50a12238b4e15291 Mon Sep 17 00:00:00 2001 From: Ehco Date: Tue, 21 Dec 2021 16:35:47 +0800 Subject: [PATCH] openapi(dm): add task config template releated openapi (#3656) --- dm/dm/master/openapi.go | 118 ++++ dm/dm/master/openapi_test.go | 133 +++++ dm/openapi/gen.client.go | 1088 ++++++++++++++++++++++++++++------ dm/openapi/gen.server.go | 280 ++++++--- dm/openapi/gen.types.go | 27 + dm/openapi/spec/dm.yaml | 176 ++++++ 6 files changed, 1571 insertions(+), 251 deletions(-) diff --git a/dm/dm/master/openapi.go b/dm/dm/master/openapi.go index dd6ba717553..610265e0ea3 100644 --- a/dm/dm/master/openapi.go +++ b/dm/dm/master/openapi.go @@ -33,6 +33,7 @@ import ( "github.com/pingcap/tiflow/dm/dm/pb" "github.com/pingcap/tiflow/dm/openapi" "github.com/pingcap/tiflow/dm/pkg/conn" + "github.com/pingcap/tiflow/dm/pkg/ha" "github.com/pingcap/tiflow/dm/pkg/log" "github.com/pingcap/tiflow/dm/pkg/terror" "github.com/pingcap/tiflow/dm/pkg/utils" @@ -822,6 +823,123 @@ func (s *Server) DMAPIOperateTableStructure(c *gin.Context, taskName string, sou } } +// DMAPIImportTaskConfig create task_config_template url is: (POST /api/v1/task/configs/import). +func (s *Server) DMAPIImportTaskConfig(c *gin.Context) { + var req openapi.TaskConfigRequest + if err := c.Bind(&req); err != nil { + _ = c.Error(err) + return + } + resp := openapi.TaskConfigResponse{ + FailedTaskList: []struct { + ErrorMsg string `json:"error_msg"` + TaskName string `json:"task_name"` + }{}, + SuccessTaskList: []string{}, + } + for _, task := range config.SubTaskConfigsToOpenAPITask(s.scheduler.GetSubTaskCfgs()) { + if err := ha.PutOpenAPITaskConfig(s.etcdClient, task, req.Overwrite); err != nil { + resp.FailedTaskList = append(resp.FailedTaskList, struct { + ErrorMsg string `json:"error_msg"` + TaskName string `json:"task_name"` + }{ + ErrorMsg: err.Error(), + TaskName: task.Name, + }) + } else { + resp.SuccessTaskList = append(resp.SuccessTaskList, task.Name) + } + } + c.IndentedJSON(http.StatusAccepted, resp) +} + +// DMAPICreateTaskConfig create task_config_template url is: (POST /api/task/configs). +func (s *Server) DMAPICreateTaskConfig(c *gin.Context) { + task := &openapi.Task{} + if err := c.Bind(task); err != nil { + _ = c.Error(err) + return + } + if err := task.Adjust(); err != nil { + _ = c.Error(err) + return + } + // prepare target db config + newCtx := c.Request.Context() + toDBCfg := config.GetTargetDBCfgFromOpenAPITask(task) + if adjustDBErr := adjustTargetDB(newCtx, toDBCfg); adjustDBErr != nil { + _ = c.Error(terror.WithClass(adjustDBErr, terror.ClassDMMaster)) + return + } + if err := ha.PutOpenAPITaskConfig(s.etcdClient, *task, false); err != nil { + _ = c.Error(err) + return + } + c.IndentedJSON(http.StatusCreated, task) +} + +// DMAPIGetTaskConfigList get task_config_template list url is: (GET /api/v1/task/configs). +func (s *Server) DMAPIGetTaskConfigList(c *gin.Context) { + TaskConfigList, err := ha.GetAllOpenAPITaskConfig(s.etcdClient) + if err != nil { + _ = c.Error(err) + return + } + taskList := make([]openapi.Task, len(TaskConfigList)) + for i, TaskConfig := range TaskConfigList { + taskList[i] = *TaskConfig + } + resp := openapi.GetTaskListResponse{Total: len(TaskConfigList), Data: taskList} + c.IndentedJSON(http.StatusOK, resp) +} + +// DMAPIDeleteTaskConfig delete task_config_template url is: (DELETE /api/v1/task/configs/{task-name}). +func (s *Server) DMAPIDeleteTaskConfig(c *gin.Context, taskName string) { + if err := ha.DeleteOpenAPITaskConfig(s.etcdClient, taskName); err != nil { + _ = c.Error(err) + return + } + c.Status(http.StatusNoContent) +} + +// DMAPIGetTaskConfig get task_config_template url is: (GET /api/v1/task/configs/{task-name}). +func (s *Server) DMAPIGetTaskConfig(c *gin.Context, taskName string) { + task, err := ha.GetOpenAPITaskConfig(s.etcdClient, taskName) + if err != nil { + _ = c.Error(err) + return + } + if task == nil { + _ = c.Error(terror.ErrOpenAPITaskConfigNotExist.Generate(taskName)) + return + } + c.IndentedJSON(http.StatusOK, task) +} + +// DMAPUpdateTaskConfig update task_config_template url is: (PUT /api/v1/task/configs/{task-name}). +func (s *Server) DMAPUpdateTaskConfig(c *gin.Context, taskName string) { + task := &openapi.Task{} + if err := c.Bind(task); err != nil { + _ = c.Error(err) + return + } + if err := task.Adjust(); err != nil { + _ = c.Error(err) + return + } + newCtx := c.Request.Context() + toDBCfg := config.GetTargetDBCfgFromOpenAPITask(task) + if adjustDBErr := adjustTargetDB(newCtx, toDBCfg); adjustDBErr != nil { + _ = c.Error(terror.WithClass(adjustDBErr, terror.ClassDMMaster)) + return + } + if err := ha.UpdateOpenAPITaskConfig(s.etcdClient, *task); err != nil { + _ = c.Error(err) + return + } + c.IndentedJSON(http.StatusOK, task) +} + func terrorHTTPErrorHandler() gin.HandlerFunc { return func(c *gin.Context) { c.Next() diff --git a/dm/dm/master/openapi_test.go b/dm/dm/master/openapi_test.go index a1f7b869e84..a139c43d9c0 100644 --- a/dm/dm/master/openapi_test.go +++ b/dm/dm/master/openapi_test.go @@ -496,6 +496,33 @@ func (t *openAPISuite) TestTaskAPI(c *check.C) { c.Assert(resultTaskList.Total, check.Equals, 1) c.Assert(resultTaskList.Data[0].Name, check.Equals, task.Name) + // test batch import task config + taskBatchImportURL := "/api/v1/task/configs/import" + req := openapi.TaskConfigRequest{Overwrite: false} + result = testutil.NewRequest().Post(taskBatchImportURL).WithJsonBody(req).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusAccepted) + var resp openapi.TaskConfigResponse + c.Assert(result.UnmarshalBodyToObject(&resp), check.IsNil) + c.Assert(resp.SuccessTaskList, check.HasLen, 1) + c.Assert(resp.SuccessTaskList[0], check.Equals, task.Name) + c.Assert(resp.FailedTaskList, check.HasLen, 0) + + // import again without overwrite will fail + result = testutil.NewRequest().Post(taskBatchImportURL).WithJsonBody(req).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusAccepted) + c.Assert(result.UnmarshalBodyToObject(&resp), check.IsNil) + c.Assert(resp.SuccessTaskList, check.HasLen, 0) + c.Assert(resp.FailedTaskList, check.HasLen, 1) + c.Assert(resp.FailedTaskList[0].TaskName, check.Equals, task.Name) + + // import again with overwrite will success + req.Overwrite = true + result = testutil.NewRequest().Post(taskBatchImportURL).WithJsonBody(req).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.UnmarshalBodyToObject(&resp), check.IsNil) + c.Assert(resp.SuccessTaskList, check.HasLen, 1) + c.Assert(resp.SuccessTaskList[0], check.Equals, task.Name) + c.Assert(resp.FailedTaskList, check.HasLen, 0) + // pause and resume task pauseTaskURL := fmt.Sprintf("%s/%s/pause", taskURL, task.Name) result = testutil.NewRequest().Post(pauseTaskURL).GoWithHTTPHandler(t.testT, s.openapiHandles) @@ -634,6 +661,112 @@ func (t *openAPISuite) TestClusterAPI(c *check.C) { cancel1() } +func (t *openAPISuite) TestTaskConfigsAPI(c *check.C) { + ctx, cancel := context.WithCancel(context.Background()) + s := setupServer(ctx, c) + c.Assert(failpoint.Enable("github.com/pingcap/tiflow/dm/dm/master/MockSkipAdjustTargetDB", `return(true)`), check.IsNil) + checker.CheckSyncConfigFunc = mockCheckSyncConfig + defer func() { + checker.CheckSyncConfigFunc = checker.CheckSyncConfig + cancel() + s.Close() + c.Assert(failpoint.Disable("github.com/pingcap/tiflow/dm/dm/master/MockSkipAdjustTargetDB"), check.IsNil) + }() + + dbCfg := config.GetDBConfigForTest() + source1 := openapi.Source{ + SourceName: source1Name, + EnableGtid: false, + Host: dbCfg.Host, + Password: dbCfg.Password, + Port: dbCfg.Port, + User: dbCfg.User, + } + // create source + sourceURL := "/api/v1/sources" + result := testutil.NewRequest().Post(sourceURL).WithJsonBody(source1).GoWithHTTPHandler(t.testT, s.openapiHandles) + // check http status code + c.Assert(result.Code(), check.Equals, http.StatusCreated) + + // create task config template + url := "/api/v1/task/configs" + + task, err := fixtures.GenNoShardOpenAPITaskForTest() + c.Assert(err, check.IsNil) + // use a valid target db + task.TargetConfig.Host = dbCfg.Host + task.TargetConfig.Port = dbCfg.Port + task.TargetConfig.User = dbCfg.User + task.TargetConfig.Password = dbCfg.Password + + // create one + result = testutil.NewRequest().Post(url).WithJsonBody(task).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusCreated) + var createTaskResp openapi.Task + err = result.UnmarshalBodyToObject(&createTaskResp) + c.Assert(err, check.IsNil) + c.Assert(task.Name, check.Equals, createTaskResp.Name) + + // create again will fail + result = testutil.NewRequest().Post(url).WithJsonBody(task).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusBadRequest) + var errResp openapi.ErrorWithMessage + err = result.UnmarshalBodyToObject(&errResp) + c.Assert(err, check.IsNil) + c.Assert(errResp.ErrorCode, check.Equals, int(terror.ErrOpenAPITaskConfigExist.Code())) + + // list templates + result = testutil.NewRequest().Get(url).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusOK) + var resultTaskList openapi.GetTaskListResponse + err = result.UnmarshalBodyToObject(&resultTaskList) + c.Assert(err, check.IsNil) + c.Assert(resultTaskList.Total, check.Equals, 1) + c.Assert(resultTaskList.Data[0].Name, check.Equals, task.Name) + + // get detail + oneURL := fmt.Sprintf("%s/%s", url, task.Name) + result = testutil.NewRequest().Get(oneURL).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusOK) + var respTask openapi.Task + err = result.UnmarshalBodyToObject(&respTask) + c.Assert(err, check.IsNil) + c.Assert(respTask.Name, check.Equals, task.Name) + + // get not exist + notExistURL := fmt.Sprintf("%s/%s", url, "notexist") + result = testutil.NewRequest().Get(notExistURL).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusBadRequest) + err = result.UnmarshalBodyToObject(&errResp) + c.Assert(err, check.IsNil) + c.Assert(errResp.ErrorCode, check.Equals, int(terror.ErrOpenAPITaskConfigNotExist.Code())) + + // update + task.TaskMode = openapi.TaskTaskModeAll + result = testutil.NewRequest().Put(oneURL).WithJsonBody(task).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusOK) + err = result.UnmarshalBodyToObject(&respTask) + c.Assert(err, check.IsNil) + c.Assert(respTask.Name, check.Equals, task.Name) + + // update not exist will fail + task.Name = "notexist" + result = testutil.NewRequest().Put(notExistURL).WithJsonBody(task).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusBadRequest) + err = result.UnmarshalBodyToObject(&errResp) + c.Assert(err, check.IsNil) + c.Assert(errResp.ErrorCode, check.Equals, int(terror.ErrOpenAPITaskConfigNotExist.Code())) + + // delete task config template + result = testutil.NewRequest().Delete(oneURL).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusNoContent) + result = testutil.NewRequest().Get(url).GoWithHTTPHandler(t.testT, s.openapiHandles) + c.Assert(result.Code(), check.Equals, http.StatusOK) + err = result.UnmarshalBodyToObject(&resultTaskList) + c.Assert(err, check.IsNil) + c.Assert(resultTaskList.Total, check.Equals, 0) +} + func setupServer(ctx context.Context, c *check.C) *Server { // create a new cluster cfg1 := NewConfig() diff --git a/dm/openapi/gen.client.go b/dm/openapi/gen.client.go index 3075c625ac1..d4aebd80ee9 100644 --- a/dm/openapi/gen.client.go +++ b/dm/openapi/gen.client.go @@ -149,6 +149,28 @@ type ClientInterface interface { DMAPITransferSource(ctx context.Context, sourceName string, body DMAPITransferSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + // DMAPIGetTaskConfigList request + DMAPIGetTaskConfigList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) + + // DMAPICreateTaskConfig request with any body + DMAPICreateTaskConfigWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + DMAPICreateTaskConfig(ctx context.Context, body DMAPICreateTaskConfigJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // DMAPIImportTaskConfig request with any body + DMAPIImportTaskConfigWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) + + DMAPIImportTaskConfig(ctx context.Context, body DMAPIImportTaskConfigJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) + + // DMAPIDeleteTaskConfig request + DMAPIDeleteTaskConfig(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // DMAPIGetTaskConfig request + DMAPIGetTaskConfig(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error) + + // DMAPUpdateTaskConfig request + DMAPUpdateTaskConfig(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error) + // DMAPIGetTaskList request DMAPIGetTaskList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) @@ -443,6 +465,102 @@ func (c *Client) DMAPITransferSource(ctx context.Context, sourceName string, bod return c.Client.Do(req) } +func (c *Client) DMAPIGetTaskConfigList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDMAPIGetTaskConfigListRequest(c.Server) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) DMAPICreateTaskConfigWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDMAPICreateTaskConfigRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) DMAPICreateTaskConfig(ctx context.Context, body DMAPICreateTaskConfigJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDMAPICreateTaskConfigRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) DMAPIImportTaskConfigWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDMAPIImportTaskConfigRequestWithBody(c.Server, contentType, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) DMAPIImportTaskConfig(ctx context.Context, body DMAPIImportTaskConfigJSONRequestBody, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDMAPIImportTaskConfigRequest(c.Server, body) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) DMAPIDeleteTaskConfig(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDMAPIDeleteTaskConfigRequest(c.Server, taskName) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) DMAPIGetTaskConfig(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDMAPIGetTaskConfigRequest(c.Server, taskName) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + +func (c *Client) DMAPUpdateTaskConfig(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*http.Response, error) { + req, err := NewDMAPUpdateTaskConfigRequest(c.Server, taskName) + if err != nil { + return nil, err + } + req = req.WithContext(ctx) + if err := c.applyEditors(ctx, req, reqEditors); err != nil { + return nil, err + } + return c.Client.Do(req) +} + func (c *Client) DMAPIGetTaskList(ctx context.Context, reqEditors ...RequestEditorFn) (*http.Response, error) { req, err := NewDMAPIGetTaskListRequest(c.Server) if err != nil { @@ -1254,8 +1372,8 @@ func NewDMAPITransferSourceRequestWithBody(server string, sourceName string, con return req, nil } -// NewDMAPIGetTaskListRequest generates requests for DMAPIGetTaskList -func NewDMAPIGetTaskListRequest(server string) (*http.Request, error) { +// NewDMAPIGetTaskConfigListRequest generates requests for DMAPIGetTaskConfigList +func NewDMAPIGetTaskConfigListRequest(server string) (*http.Request, error) { var err error serverURL, err := url.Parse(server) @@ -1263,7 +1381,7 @@ func NewDMAPIGetTaskListRequest(server string) (*http.Request, error) { return nil, err } - operationPath := fmt.Sprintf("/api/v1/tasks") + operationPath := fmt.Sprintf("/api/v1/task/configs") if operationPath[0] == '/' { operationPath = "." + operationPath } @@ -1281,19 +1399,19 @@ func NewDMAPIGetTaskListRequest(server string) (*http.Request, error) { return req, nil } -// NewDMAPIStartTaskRequest calls the generic DMAPIStartTask builder with application/json body -func NewDMAPIStartTaskRequest(server string, body DMAPIStartTaskJSONRequestBody) (*http.Request, error) { +// NewDMAPICreateTaskConfigRequest calls the generic DMAPICreateTaskConfig builder with application/json body +func NewDMAPICreateTaskConfigRequest(server string, body DMAPICreateTaskConfigJSONRequestBody) (*http.Request, error) { var bodyReader io.Reader buf, err := json.Marshal(body) if err != nil { return nil, err } bodyReader = bytes.NewReader(buf) - return NewDMAPIStartTaskRequestWithBody(server, "application/json", bodyReader) + return NewDMAPICreateTaskConfigRequestWithBody(server, "application/json", bodyReader) } -// NewDMAPIStartTaskRequestWithBody generates requests for DMAPIStartTask with any type of body -func NewDMAPIStartTaskRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { +// NewDMAPICreateTaskConfigRequestWithBody generates requests for DMAPICreateTaskConfig with any type of body +func NewDMAPICreateTaskConfigRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { var err error serverURL, err := url.Parse(server) @@ -1301,7 +1419,7 @@ func NewDMAPIStartTaskRequestWithBody(server string, contentType string, body io return nil, err } - operationPath := fmt.Sprintf("/api/v1/tasks") + operationPath := fmt.Sprintf("/api/v1/task/configs") if operationPath[0] == '/' { operationPath = "." + operationPath } @@ -1321,86 +1439,27 @@ func NewDMAPIStartTaskRequestWithBody(server string, contentType string, body io return req, nil } -// NewDMAPIDeleteTaskRequest generates requests for DMAPIDeleteTask -func NewDMAPIDeleteTaskRequest(server string, taskName string, params *DMAPIDeleteTaskParams) (*http.Request, error) { - var err error - - var pathParam0 string - - pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName) - if err != nil { - return nil, err - } - - serverURL, err := url.Parse(server) - if err != nil { - return nil, err - } - - operationPath := fmt.Sprintf("/api/v1/tasks/%s", pathParam0) - if operationPath[0] == '/' { - operationPath = "." + operationPath - } - - queryURL, err := serverURL.Parse(operationPath) - if err != nil { - return nil, err - } - - queryValues := queryURL.Query() - - if params.SourceNameList != nil { - if queryFrag, err := runtime.StyleParamWithLocation("form", true, "source_name_list", runtime.ParamLocationQuery, *params.SourceNameList); err != nil { - return nil, err - } else if parsed, err := url.ParseQuery(queryFrag); err != nil { - return nil, err - } else { - for k, v := range parsed { - for _, v2 := range v { - queryValues.Add(k, v2) - } - } - } - } - - queryURL.RawQuery = queryValues.Encode() - - req, err := http.NewRequest("DELETE", queryURL.String(), nil) - if err != nil { - return nil, err - } - - return req, nil -} - -// NewDMAPIPauseTaskRequest calls the generic DMAPIPauseTask builder with application/json body -func NewDMAPIPauseTaskRequest(server string, taskName string, body DMAPIPauseTaskJSONRequestBody) (*http.Request, error) { +// NewDMAPIImportTaskConfigRequest calls the generic DMAPIImportTaskConfig builder with application/json body +func NewDMAPIImportTaskConfigRequest(server string, body DMAPIImportTaskConfigJSONRequestBody) (*http.Request, error) { var bodyReader io.Reader buf, err := json.Marshal(body) if err != nil { return nil, err } bodyReader = bytes.NewReader(buf) - return NewDMAPIPauseTaskRequestWithBody(server, taskName, "application/json", bodyReader) + return NewDMAPIImportTaskConfigRequestWithBody(server, "application/json", bodyReader) } -// NewDMAPIPauseTaskRequestWithBody generates requests for DMAPIPauseTask with any type of body -func NewDMAPIPauseTaskRequestWithBody(server string, taskName string, contentType string, body io.Reader) (*http.Request, error) { +// NewDMAPIImportTaskConfigRequestWithBody generates requests for DMAPIImportTaskConfig with any type of body +func NewDMAPIImportTaskConfigRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { var err error - var pathParam0 string - - pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName) - if err != nil { - return nil, err - } - serverURL, err := url.Parse(server) if err != nil { return nil, err } - operationPath := fmt.Sprintf("/api/v1/tasks/%s/pause", pathParam0) + operationPath := fmt.Sprintf("/api/v1/task/configs/import") if operationPath[0] == '/' { operationPath = "." + operationPath } @@ -1420,19 +1479,8 @@ func NewDMAPIPauseTaskRequestWithBody(server string, taskName string, contentTyp return req, nil } -// NewDMAPIResumeTaskRequest calls the generic DMAPIResumeTask builder with application/json body -func NewDMAPIResumeTaskRequest(server string, taskName string, body DMAPIResumeTaskJSONRequestBody) (*http.Request, error) { - var bodyReader io.Reader - buf, err := json.Marshal(body) - if err != nil { - return nil, err - } - bodyReader = bytes.NewReader(buf) - return NewDMAPIResumeTaskRequestWithBody(server, taskName, "application/json", bodyReader) -} - -// NewDMAPIResumeTaskRequestWithBody generates requests for DMAPIResumeTask with any type of body -func NewDMAPIResumeTaskRequestWithBody(server string, taskName string, contentType string, body io.Reader) (*http.Request, error) { +// NewDMAPIDeleteTaskConfigRequest generates requests for DMAPIDeleteTaskConfig +func NewDMAPIDeleteTaskConfigRequest(server string, taskName string) (*http.Request, error) { var err error var pathParam0 string @@ -1447,7 +1495,7 @@ func NewDMAPIResumeTaskRequestWithBody(server string, taskName string, contentTy return nil, err } - operationPath := fmt.Sprintf("/api/v1/tasks/%s/resume", pathParam0) + operationPath := fmt.Sprintf("/api/v1/task/configs/%s", pathParam0) if operationPath[0] == '/' { operationPath = "." + operationPath } @@ -1457,18 +1505,16 @@ func NewDMAPIResumeTaskRequestWithBody(server string, taskName string, contentTy return nil, err } - req, err := http.NewRequest("POST", queryURL.String(), body) + req, err := http.NewRequest("DELETE", queryURL.String(), nil) if err != nil { return nil, err } - req.Header.Add("Content-Type", contentType) - return req, nil } -// NewDMAPIGetSchemaListByTaskAndSourceRequest generates requests for DMAPIGetSchemaListByTaskAndSource -func NewDMAPIGetSchemaListByTaskAndSourceRequest(server string, taskName string, sourceName string) (*http.Request, error) { +// NewDMAPIGetTaskConfigRequest generates requests for DMAPIGetTaskConfig +func NewDMAPIGetTaskConfigRequest(server string, taskName string) (*http.Request, error) { var err error var pathParam0 string @@ -1478,19 +1524,12 @@ func NewDMAPIGetSchemaListByTaskAndSourceRequest(server string, taskName string, return nil, err } - var pathParam1 string - - pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName) - if err != nil { - return nil, err - } - serverURL, err := url.Parse(server) if err != nil { return nil, err } - operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas", pathParam0, pathParam1) + operationPath := fmt.Sprintf("/api/v1/task/configs/%s", pathParam0) if operationPath[0] == '/' { operationPath = "." + operationPath } @@ -1508,8 +1547,8 @@ func NewDMAPIGetSchemaListByTaskAndSourceRequest(server string, taskName string, return req, nil } -// NewDMAPIGetTableListByTaskAndSourceRequest generates requests for DMAPIGetTableListByTaskAndSource -func NewDMAPIGetTableListByTaskAndSourceRequest(server string, taskName string, sourceName string, schemaName string) (*http.Request, error) { +// NewDMAPUpdateTaskConfigRequest generates requests for DMAPUpdateTaskConfig +func NewDMAPUpdateTaskConfigRequest(server string, taskName string) (*http.Request, error) { var err error var pathParam0 string @@ -1519,26 +1558,12 @@ func NewDMAPIGetTableListByTaskAndSourceRequest(server string, taskName string, return nil, err } - var pathParam1 string - - pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName) - if err != nil { - return nil, err - } - - var pathParam2 string - - pathParam2, err = runtime.StyleParamWithLocation("simple", false, "schema-name", runtime.ParamLocationPath, schemaName) - if err != nil { - return nil, err - } - serverURL, err := url.Parse(server) if err != nil { return nil, err } - operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas/%s", pathParam0, pathParam1, pathParam2) + operationPath := fmt.Sprintf("/api/v1/task/configs/%s", pathParam0) if operationPath[0] == '/' { operationPath = "." + operationPath } @@ -1548,7 +1573,7 @@ func NewDMAPIGetTableListByTaskAndSourceRequest(server string, taskName string, return nil, err } - req, err := http.NewRequest("GET", queryURL.String(), nil) + req, err := http.NewRequest("PUT", queryURL.String(), nil) if err != nil { return nil, err } @@ -1556,44 +1581,54 @@ func NewDMAPIGetTableListByTaskAndSourceRequest(server string, taskName string, return req, nil } -// NewDMAPIDeleteTableStructureRequest generates requests for DMAPIDeleteTableStructure -func NewDMAPIDeleteTableStructureRequest(server string, taskName string, sourceName string, schemaName string, tableName string) (*http.Request, error) { +// NewDMAPIGetTaskListRequest generates requests for DMAPIGetTaskList +func NewDMAPIGetTaskListRequest(server string) (*http.Request, error) { var err error - var pathParam0 string - - pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName) + serverURL, err := url.Parse(server) if err != nil { return nil, err } - var pathParam1 string + operationPath := fmt.Sprintf("/api/v1/tasks") + if operationPath[0] == '/' { + operationPath = "." + operationPath + } - pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName) + queryURL, err := serverURL.Parse(operationPath) if err != nil { return nil, err } - var pathParam2 string - - pathParam2, err = runtime.StyleParamWithLocation("simple", false, "schema-name", runtime.ParamLocationPath, schemaName) + req, err := http.NewRequest("GET", queryURL.String(), nil) if err != nil { return nil, err } - var pathParam3 string + return req, nil +} - pathParam3, err = runtime.StyleParamWithLocation("simple", false, "table-name", runtime.ParamLocationPath, tableName) +// NewDMAPIStartTaskRequest calls the generic DMAPIStartTask builder with application/json body +func NewDMAPIStartTaskRequest(server string, body DMAPIStartTaskJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) if err != nil { return nil, err } + bodyReader = bytes.NewReader(buf) + return NewDMAPIStartTaskRequestWithBody(server, "application/json", bodyReader) +} + +// NewDMAPIStartTaskRequestWithBody generates requests for DMAPIStartTask with any type of body +func NewDMAPIStartTaskRequestWithBody(server string, contentType string, body io.Reader) (*http.Request, error) { + var err error serverURL, err := url.Parse(server) if err != nil { return nil, err } - operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas/%s/%s", pathParam0, pathParam1, pathParam2, pathParam3) + operationPath := fmt.Sprintf("/api/v1/tasks") if operationPath[0] == '/' { operationPath = "." + operationPath } @@ -1603,16 +1638,18 @@ func NewDMAPIDeleteTableStructureRequest(server string, taskName string, sourceN return nil, err } - req, err := http.NewRequest("DELETE", queryURL.String(), nil) + req, err := http.NewRequest("POST", queryURL.String(), body) if err != nil { return nil, err } + req.Header.Add("Content-Type", contentType) + return req, nil } -// NewDMAPIGetTableStructureRequest generates requests for DMAPIGetTableStructure -func NewDMAPIGetTableStructureRequest(server string, taskName string, sourceName string, schemaName string, tableName string) (*http.Request, error) { +// NewDMAPIDeleteTaskRequest generates requests for DMAPIDeleteTask +func NewDMAPIDeleteTaskRequest(server string, taskName string, params *DMAPIDeleteTaskParams) (*http.Request, error) { var err error var pathParam0 string @@ -1622,9 +1659,299 @@ func NewDMAPIGetTableStructureRequest(server string, taskName string, sourceName return nil, err } - var pathParam1 string - - pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName) + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/v1/tasks/%s", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + queryValues := queryURL.Query() + + if params.SourceNameList != nil { + if queryFrag, err := runtime.StyleParamWithLocation("form", true, "source_name_list", runtime.ParamLocationQuery, *params.SourceNameList); err != nil { + return nil, err + } else if parsed, err := url.ParseQuery(queryFrag); err != nil { + return nil, err + } else { + for k, v := range parsed { + for _, v2 := range v { + queryValues.Add(k, v2) + } + } + } + } + + queryURL.RawQuery = queryValues.Encode() + + req, err := http.NewRequest("DELETE", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewDMAPIPauseTaskRequest calls the generic DMAPIPauseTask builder with application/json body +func NewDMAPIPauseTaskRequest(server string, taskName string, body DMAPIPauseTaskJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewDMAPIPauseTaskRequestWithBody(server, taskName, "application/json", bodyReader) +} + +// NewDMAPIPauseTaskRequestWithBody generates requests for DMAPIPauseTask with any type of body +func NewDMAPIPauseTaskRequestWithBody(server string, taskName string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/v1/tasks/%s/pause", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewDMAPIResumeTaskRequest calls the generic DMAPIResumeTask builder with application/json body +func NewDMAPIResumeTaskRequest(server string, taskName string, body DMAPIResumeTaskJSONRequestBody) (*http.Request, error) { + var bodyReader io.Reader + buf, err := json.Marshal(body) + if err != nil { + return nil, err + } + bodyReader = bytes.NewReader(buf) + return NewDMAPIResumeTaskRequestWithBody(server, taskName, "application/json", bodyReader) +} + +// NewDMAPIResumeTaskRequestWithBody generates requests for DMAPIResumeTask with any type of body +func NewDMAPIResumeTaskRequestWithBody(server string, taskName string, contentType string, body io.Reader) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/v1/tasks/%s/resume", pathParam0) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("POST", queryURL.String(), body) + if err != nil { + return nil, err + } + + req.Header.Add("Content-Type", contentType) + + return req, nil +} + +// NewDMAPIGetSchemaListByTaskAndSourceRequest generates requests for DMAPIGetSchemaListByTaskAndSource +func NewDMAPIGetSchemaListByTaskAndSourceRequest(server string, taskName string, sourceName string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName) + if err != nil { + return nil, err + } + + var pathParam1 string + + pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas", pathParam0, pathParam1) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewDMAPIGetTableListByTaskAndSourceRequest generates requests for DMAPIGetTableListByTaskAndSource +func NewDMAPIGetTableListByTaskAndSourceRequest(server string, taskName string, sourceName string, schemaName string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName) + if err != nil { + return nil, err + } + + var pathParam1 string + + pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName) + if err != nil { + return nil, err + } + + var pathParam2 string + + pathParam2, err = runtime.StyleParamWithLocation("simple", false, "schema-name", runtime.ParamLocationPath, schemaName) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas/%s", pathParam0, pathParam1, pathParam2) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("GET", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewDMAPIDeleteTableStructureRequest generates requests for DMAPIDeleteTableStructure +func NewDMAPIDeleteTableStructureRequest(server string, taskName string, sourceName string, schemaName string, tableName string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName) + if err != nil { + return nil, err + } + + var pathParam1 string + + pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName) + if err != nil { + return nil, err + } + + var pathParam2 string + + pathParam2, err = runtime.StyleParamWithLocation("simple", false, "schema-name", runtime.ParamLocationPath, schemaName) + if err != nil { + return nil, err + } + + var pathParam3 string + + pathParam3, err = runtime.StyleParamWithLocation("simple", false, "table-name", runtime.ParamLocationPath, tableName) + if err != nil { + return nil, err + } + + serverURL, err := url.Parse(server) + if err != nil { + return nil, err + } + + operationPath := fmt.Sprintf("/api/v1/tasks/%s/sources/%s/schemas/%s/%s", pathParam0, pathParam1, pathParam2, pathParam3) + if operationPath[0] == '/' { + operationPath = "." + operationPath + } + + queryURL, err := serverURL.Parse(operationPath) + if err != nil { + return nil, err + } + + req, err := http.NewRequest("DELETE", queryURL.String(), nil) + if err != nil { + return nil, err + } + + return req, nil +} + +// NewDMAPIGetTableStructureRequest generates requests for DMAPIGetTableStructure +func NewDMAPIGetTableStructureRequest(server string, taskName string, sourceName string, schemaName string, tableName string) (*http.Request, error) { + var err error + + var pathParam0 string + + pathParam0, err = runtime.StyleParamWithLocation("simple", false, "task-name", runtime.ParamLocationPath, taskName) + if err != nil { + return nil, err + } + + var pathParam1 string + + pathParam1, err = runtime.StyleParamWithLocation("simple", false, "source-name", runtime.ParamLocationPath, sourceName) if err != nil { return nil, err } @@ -1888,6 +2215,28 @@ type ClientWithResponsesInterface interface { DMAPITransferSourceWithResponse(ctx context.Context, sourceName string, body DMAPITransferSourceJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPITransferSourceResponse, error) + // DMAPIGetTaskConfigList request + DMAPIGetTaskConfigListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetTaskConfigListResponse, error) + + // DMAPICreateTaskConfig request with any body + DMAPICreateTaskConfigWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPICreateTaskConfigResponse, error) + + DMAPICreateTaskConfigWithResponse(ctx context.Context, body DMAPICreateTaskConfigJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPICreateTaskConfigResponse, error) + + // DMAPIImportTaskConfig request with any body + DMAPIImportTaskConfigWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIImportTaskConfigResponse, error) + + DMAPIImportTaskConfigWithResponse(ctx context.Context, body DMAPIImportTaskConfigJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIImportTaskConfigResponse, error) + + // DMAPIDeleteTaskConfig request + DMAPIDeleteTaskConfigWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPIDeleteTaskConfigResponse, error) + + // DMAPIGetTaskConfig request + DMAPIGetTaskConfigWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPIGetTaskConfigResponse, error) + + // DMAPUpdateTaskConfig request + DMAPUpdateTaskConfigWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPUpdateTaskConfigResponse, error) + // DMAPIGetTaskList request DMAPIGetTaskListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetTaskListResponse, error) @@ -2092,7 +2441,142 @@ type DMAPICreateSourceResponse struct { } // Status returns HTTPResponse.Status -func (r DMAPICreateSourceResponse) Status() string { +func (r DMAPICreateSourceResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r DMAPICreateSourceResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type DMAPIDeleteSourceResponse struct { + Body []byte + HTTPResponse *http.Response + JSON204 *DeleteSourceResponse + JSON400 *ErrorWithMessage +} + +// Status returns HTTPResponse.Status +func (r DMAPIDeleteSourceResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r DMAPIDeleteSourceResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type DMAPIPauseRelayResponse struct { + Body []byte + HTTPResponse *http.Response + JSON400 *ErrorWithMessage +} + +// Status returns HTTPResponse.Status +func (r DMAPIPauseRelayResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r DMAPIPauseRelayResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type DMAPIResumeRelayResponse struct { + Body []byte + HTTPResponse *http.Response + JSON400 *ErrorWithMessage +} + +// Status returns HTTPResponse.Status +func (r DMAPIResumeRelayResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r DMAPIResumeRelayResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type DMAPIGetSourceSchemaListResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *SchemaNameList + JSON400 *ErrorWithMessage +} + +// Status returns HTTPResponse.Status +func (r DMAPIGetSourceSchemaListResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r DMAPIGetSourceSchemaListResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type DMAPIGetSourceTableListResponse struct { + Body []byte + HTTPResponse *http.Response + JSON200 *TableNameList + JSON400 *ErrorWithMessage +} + +// Status returns HTTPResponse.Status +func (r DMAPIGetSourceTableListResponse) Status() string { + if r.HTTPResponse != nil { + return r.HTTPResponse.Status + } + return http.StatusText(0) +} + +// StatusCode returns HTTPResponse.StatusCode +func (r DMAPIGetSourceTableListResponse) StatusCode() int { + if r.HTTPResponse != nil { + return r.HTTPResponse.StatusCode + } + return 0 +} + +type DMAPIStartRelayResponse struct { + Body []byte + HTTPResponse *http.Response + JSON400 *ErrorWithMessage +} + +// Status returns HTTPResponse.Status +func (r DMAPIStartRelayResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2100,22 +2584,22 @@ func (r DMAPICreateSourceResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPICreateSourceResponse) StatusCode() int { +func (r DMAPIStartRelayResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } return 0 } -type DMAPIDeleteSourceResponse struct { +type DMAPIGetSourceStatusResponse struct { Body []byte HTTPResponse *http.Response - JSON204 *DeleteSourceResponse + JSON200 *GetSourceStatusResponse JSON400 *ErrorWithMessage } // Status returns HTTPResponse.Status -func (r DMAPIDeleteSourceResponse) Status() string { +func (r DMAPIGetSourceStatusResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2123,21 +2607,21 @@ func (r DMAPIDeleteSourceResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPIDeleteSourceResponse) StatusCode() int { +func (r DMAPIGetSourceStatusResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } return 0 } -type DMAPIPauseRelayResponse struct { +type DMAPIStopRelayResponse struct { Body []byte HTTPResponse *http.Response JSON400 *ErrorWithMessage } // Status returns HTTPResponse.Status -func (r DMAPIPauseRelayResponse) Status() string { +func (r DMAPIStopRelayResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2145,21 +2629,21 @@ func (r DMAPIPauseRelayResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPIPauseRelayResponse) StatusCode() int { +func (r DMAPIStopRelayResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } return 0 } -type DMAPIResumeRelayResponse struct { +type DMAPITransferSourceResponse struct { Body []byte HTTPResponse *http.Response JSON400 *ErrorWithMessage } // Status returns HTTPResponse.Status -func (r DMAPIResumeRelayResponse) Status() string { +func (r DMAPITransferSourceResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2167,22 +2651,22 @@ func (r DMAPIResumeRelayResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPIResumeRelayResponse) StatusCode() int { +func (r DMAPITransferSourceResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } return 0 } -type DMAPIGetSourceSchemaListResponse struct { +type DMAPIGetTaskConfigListResponse struct { Body []byte HTTPResponse *http.Response - JSON200 *SchemaNameList + JSON200 *GetTaskListResponse JSON400 *ErrorWithMessage } // Status returns HTTPResponse.Status -func (r DMAPIGetSourceSchemaListResponse) Status() string { +func (r DMAPIGetTaskConfigListResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2190,22 +2674,22 @@ func (r DMAPIGetSourceSchemaListResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPIGetSourceSchemaListResponse) StatusCode() int { +func (r DMAPIGetTaskConfigListResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } return 0 } -type DMAPIGetSourceTableListResponse struct { +type DMAPICreateTaskConfigResponse struct { Body []byte HTTPResponse *http.Response - JSON200 *TableNameList + JSON201 *Task JSON400 *ErrorWithMessage } // Status returns HTTPResponse.Status -func (r DMAPIGetSourceTableListResponse) Status() string { +func (r DMAPICreateTaskConfigResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2213,21 +2697,22 @@ func (r DMAPIGetSourceTableListResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPIGetSourceTableListResponse) StatusCode() int { +func (r DMAPICreateTaskConfigResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } return 0 } -type DMAPIStartRelayResponse struct { +type DMAPIImportTaskConfigResponse struct { Body []byte HTTPResponse *http.Response + JSON202 *TaskConfigResponse JSON400 *ErrorWithMessage } // Status returns HTTPResponse.Status -func (r DMAPIStartRelayResponse) Status() string { +func (r DMAPIImportTaskConfigResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2235,22 +2720,21 @@ func (r DMAPIStartRelayResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPIStartRelayResponse) StatusCode() int { +func (r DMAPIImportTaskConfigResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } return 0 } -type DMAPIGetSourceStatusResponse struct { +type DMAPIDeleteTaskConfigResponse struct { Body []byte HTTPResponse *http.Response - JSON200 *GetSourceStatusResponse JSON400 *ErrorWithMessage } // Status returns HTTPResponse.Status -func (r DMAPIGetSourceStatusResponse) Status() string { +func (r DMAPIDeleteTaskConfigResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2258,21 +2742,22 @@ func (r DMAPIGetSourceStatusResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPIGetSourceStatusResponse) StatusCode() int { +func (r DMAPIDeleteTaskConfigResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } return 0 } -type DMAPIStopRelayResponse struct { +type DMAPIGetTaskConfigResponse struct { Body []byte HTTPResponse *http.Response + JSON200 *Task JSON400 *ErrorWithMessage } // Status returns HTTPResponse.Status -func (r DMAPIStopRelayResponse) Status() string { +func (r DMAPIGetTaskConfigResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2280,21 +2765,22 @@ func (r DMAPIStopRelayResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPIStopRelayResponse) StatusCode() int { +func (r DMAPIGetTaskConfigResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } return 0 } -type DMAPITransferSourceResponse struct { +type DMAPUpdateTaskConfigResponse struct { Body []byte HTTPResponse *http.Response + JSON200 *Task JSON400 *ErrorWithMessage } // Status returns HTTPResponse.Status -func (r DMAPITransferSourceResponse) Status() string { +func (r DMAPUpdateTaskConfigResponse) Status() string { if r.HTTPResponse != nil { return r.HTTPResponse.Status } @@ -2302,7 +2788,7 @@ func (r DMAPITransferSourceResponse) Status() string { } // StatusCode returns HTTPResponse.StatusCode -func (r DMAPITransferSourceResponse) StatusCode() int { +func (r DMAPUpdateTaskConfigResponse) StatusCode() int { if r.HTTPResponse != nil { return r.HTTPResponse.StatusCode } @@ -2742,6 +3228,76 @@ func (c *ClientWithResponses) DMAPITransferSourceWithResponse(ctx context.Contex return ParseDMAPITransferSourceResponse(rsp) } +// DMAPIGetTaskConfigListWithResponse request returning *DMAPIGetTaskConfigListResponse +func (c *ClientWithResponses) DMAPIGetTaskConfigListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetTaskConfigListResponse, error) { + rsp, err := c.DMAPIGetTaskConfigList(ctx, reqEditors...) + if err != nil { + return nil, err + } + return ParseDMAPIGetTaskConfigListResponse(rsp) +} + +// DMAPICreateTaskConfigWithBodyWithResponse request with arbitrary body returning *DMAPICreateTaskConfigResponse +func (c *ClientWithResponses) DMAPICreateTaskConfigWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPICreateTaskConfigResponse, error) { + rsp, err := c.DMAPICreateTaskConfigWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseDMAPICreateTaskConfigResponse(rsp) +} + +func (c *ClientWithResponses) DMAPICreateTaskConfigWithResponse(ctx context.Context, body DMAPICreateTaskConfigJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPICreateTaskConfigResponse, error) { + rsp, err := c.DMAPICreateTaskConfig(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseDMAPICreateTaskConfigResponse(rsp) +} + +// DMAPIImportTaskConfigWithBodyWithResponse request with arbitrary body returning *DMAPIImportTaskConfigResponse +func (c *ClientWithResponses) DMAPIImportTaskConfigWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...RequestEditorFn) (*DMAPIImportTaskConfigResponse, error) { + rsp, err := c.DMAPIImportTaskConfigWithBody(ctx, contentType, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseDMAPIImportTaskConfigResponse(rsp) +} + +func (c *ClientWithResponses) DMAPIImportTaskConfigWithResponse(ctx context.Context, body DMAPIImportTaskConfigJSONRequestBody, reqEditors ...RequestEditorFn) (*DMAPIImportTaskConfigResponse, error) { + rsp, err := c.DMAPIImportTaskConfig(ctx, body, reqEditors...) + if err != nil { + return nil, err + } + return ParseDMAPIImportTaskConfigResponse(rsp) +} + +// DMAPIDeleteTaskConfigWithResponse request returning *DMAPIDeleteTaskConfigResponse +func (c *ClientWithResponses) DMAPIDeleteTaskConfigWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPIDeleteTaskConfigResponse, error) { + rsp, err := c.DMAPIDeleteTaskConfig(ctx, taskName, reqEditors...) + if err != nil { + return nil, err + } + return ParseDMAPIDeleteTaskConfigResponse(rsp) +} + +// DMAPIGetTaskConfigWithResponse request returning *DMAPIGetTaskConfigResponse +func (c *ClientWithResponses) DMAPIGetTaskConfigWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPIGetTaskConfigResponse, error) { + rsp, err := c.DMAPIGetTaskConfig(ctx, taskName, reqEditors...) + if err != nil { + return nil, err + } + return ParseDMAPIGetTaskConfigResponse(rsp) +} + +// DMAPUpdateTaskConfigWithResponse request returning *DMAPUpdateTaskConfigResponse +func (c *ClientWithResponses) DMAPUpdateTaskConfigWithResponse(ctx context.Context, taskName string, reqEditors ...RequestEditorFn) (*DMAPUpdateTaskConfigResponse, error) { + rsp, err := c.DMAPUpdateTaskConfig(ctx, taskName, reqEditors...) + if err != nil { + return nil, err + } + return ParseDMAPUpdateTaskConfigResponse(rsp) +} + // DMAPIGetTaskListWithResponse request returning *DMAPIGetTaskListResponse func (c *ClientWithResponses) DMAPIGetTaskListWithResponse(ctx context.Context, reqEditors ...RequestEditorFn) (*DMAPIGetTaskListResponse, error) { rsp, err := c.DMAPIGetTaskList(ctx, reqEditors...) @@ -3336,6 +3892,196 @@ func ParseDMAPITransferSourceResponse(rsp *http.Response) (*DMAPITransferSourceR return response, nil } +// ParseDMAPIGetTaskConfigListResponse parses an HTTP response from a DMAPIGetTaskConfigListWithResponse call +func ParseDMAPIGetTaskConfigListResponse(rsp *http.Response) (*DMAPIGetTaskConfigListResponse, error) { + bodyBytes, err := ioutil.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &DMAPIGetTaskConfigListResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest GetTaskListResponse + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorWithMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + } + + return response, nil +} + +// ParseDMAPICreateTaskConfigResponse parses an HTTP response from a DMAPICreateTaskConfigWithResponse call +func ParseDMAPICreateTaskConfigResponse(rsp *http.Response) (*DMAPICreateTaskConfigResponse, error) { + bodyBytes, err := ioutil.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &DMAPICreateTaskConfigResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 201: + var dest Task + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON201 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorWithMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + } + + return response, nil +} + +// ParseDMAPIImportTaskConfigResponse parses an HTTP response from a DMAPIImportTaskConfigWithResponse call +func ParseDMAPIImportTaskConfigResponse(rsp *http.Response) (*DMAPIImportTaskConfigResponse, error) { + bodyBytes, err := ioutil.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &DMAPIImportTaskConfigResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 202: + var dest TaskConfigResponse + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON202 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorWithMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + } + + return response, nil +} + +// ParseDMAPIDeleteTaskConfigResponse parses an HTTP response from a DMAPIDeleteTaskConfigWithResponse call +func ParseDMAPIDeleteTaskConfigResponse(rsp *http.Response) (*DMAPIDeleteTaskConfigResponse, error) { + bodyBytes, err := ioutil.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &DMAPIDeleteTaskConfigResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorWithMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + } + + return response, nil +} + +// ParseDMAPIGetTaskConfigResponse parses an HTTP response from a DMAPIGetTaskConfigWithResponse call +func ParseDMAPIGetTaskConfigResponse(rsp *http.Response) (*DMAPIGetTaskConfigResponse, error) { + bodyBytes, err := ioutil.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &DMAPIGetTaskConfigResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest Task + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorWithMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + } + + return response, nil +} + +// ParseDMAPUpdateTaskConfigResponse parses an HTTP response from a DMAPUpdateTaskConfigWithResponse call +func ParseDMAPUpdateTaskConfigResponse(rsp *http.Response) (*DMAPUpdateTaskConfigResponse, error) { + bodyBytes, err := ioutil.ReadAll(rsp.Body) + defer func() { _ = rsp.Body.Close() }() + if err != nil { + return nil, err + } + + response := &DMAPUpdateTaskConfigResponse{ + Body: bodyBytes, + HTTPResponse: rsp, + } + + switch { + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 200: + var dest Task + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON200 = &dest + + case strings.Contains(rsp.Header.Get("Content-Type"), "json") && rsp.StatusCode == 400: + var dest ErrorWithMessage + if err := json.Unmarshal(bodyBytes, &dest); err != nil { + return nil, err + } + response.JSON400 = &dest + + } + + return response, nil +} + // ParseDMAPIGetTaskListResponse parses an HTTP response from a DMAPIGetTaskListWithResponse call func ParseDMAPIGetTaskListResponse(rsp *http.Response) (*DMAPIGetTaskListResponse, error) { bodyBytes, err := ioutil.ReadAll(rsp.Body) diff --git a/dm/openapi/gen.server.go b/dm/openapi/gen.server.go index e3bec85ff71..518da77bf7c 100644 --- a/dm/openapi/gen.server.go +++ b/dm/openapi/gen.server.go @@ -71,6 +71,24 @@ type ServerInterface interface { // transfer source to a free worker // (POST /api/v1/sources/{source-name}/transfer) DMAPITransferSource(c *gin.Context, sourceName string) + // get task config list + // (GET /api/v1/task/configs) + DMAPIGetTaskConfigList(c *gin.Context) + // create task config + // (POST /api/v1/task/configs) + DMAPICreateTaskConfig(c *gin.Context) + // import task config + // (POST /api/v1/task/configs/import) + DMAPIImportTaskConfig(c *gin.Context) + // delete task_config + // (DELETE /api/v1/task/configs/{task-name}) + DMAPIDeleteTaskConfig(c *gin.Context, taskName string) + // get task_config + // (GET /api/v1/task/configs/{task-name}) + DMAPIGetTaskConfig(c *gin.Context, taskName string) + // update task_config + // (PUT /api/v1/task/configs/{task-name}) + DMAPUpdateTaskConfig(c *gin.Context, taskName string) // get task list // (GET /api/v1/tasks) DMAPIGetTaskList(c *gin.Context) @@ -425,6 +443,93 @@ func (siw *ServerInterfaceWrapper) DMAPITransferSource(c *gin.Context) { siw.Handler.DMAPITransferSource(c, sourceName) } +// DMAPIGetTaskConfigList operation middleware +func (siw *ServerInterfaceWrapper) DMAPIGetTaskConfigList(c *gin.Context) { + for _, middleware := range siw.HandlerMiddlewares { + middleware(c) + } + + siw.Handler.DMAPIGetTaskConfigList(c) +} + +// DMAPICreateTaskConfig operation middleware +func (siw *ServerInterfaceWrapper) DMAPICreateTaskConfig(c *gin.Context) { + for _, middleware := range siw.HandlerMiddlewares { + middleware(c) + } + + siw.Handler.DMAPICreateTaskConfig(c) +} + +// DMAPIImportTaskConfig operation middleware +func (siw *ServerInterfaceWrapper) DMAPIImportTaskConfig(c *gin.Context) { + for _, middleware := range siw.HandlerMiddlewares { + middleware(c) + } + + siw.Handler.DMAPIImportTaskConfig(c) +} + +// DMAPIDeleteTaskConfig operation middleware +func (siw *ServerInterfaceWrapper) DMAPIDeleteTaskConfig(c *gin.Context) { + var err error + + // ------------- Path parameter "task-name" ------------- + var taskName string + + err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName) + if err != nil { + c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)}) + return + } + + for _, middleware := range siw.HandlerMiddlewares { + middleware(c) + } + + siw.Handler.DMAPIDeleteTaskConfig(c, taskName) +} + +// DMAPIGetTaskConfig operation middleware +func (siw *ServerInterfaceWrapper) DMAPIGetTaskConfig(c *gin.Context) { + var err error + + // ------------- Path parameter "task-name" ------------- + var taskName string + + err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName) + if err != nil { + c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)}) + return + } + + for _, middleware := range siw.HandlerMiddlewares { + middleware(c) + } + + siw.Handler.DMAPIGetTaskConfig(c, taskName) +} + +// DMAPUpdateTaskConfig operation middleware +func (siw *ServerInterfaceWrapper) DMAPUpdateTaskConfig(c *gin.Context) { + var err error + + // ------------- Path parameter "task-name" ------------- + var taskName string + + err = runtime.BindStyledParameter("simple", false, "task-name", c.Param("task-name"), &taskName) + if err != nil { + c.JSON(http.StatusBadRequest, gin.H{"msg": fmt.Sprintf("Invalid format for parameter task-name: %s", err)}) + return + } + + for _, middleware := range siw.HandlerMiddlewares { + middleware(c) + } + + siw.Handler.DMAPUpdateTaskConfig(c, taskName) +} + // DMAPIGetTaskList operation middleware func (siw *ServerInterfaceWrapper) DMAPIGetTaskList(c *gin.Context) { for _, middleware := range siw.HandlerMiddlewares { @@ -809,6 +914,18 @@ func RegisterHandlersWithOptions(router *gin.Engine, si ServerInterface, options router.POST(options.BaseURL+"/api/v1/sources/:source-name/transfer", wrapper.DMAPITransferSource) + router.GET(options.BaseURL+"/api/v1/task/configs", wrapper.DMAPIGetTaskConfigList) + + router.POST(options.BaseURL+"/api/v1/task/configs", wrapper.DMAPICreateTaskConfig) + + router.POST(options.BaseURL+"/api/v1/task/configs/import", wrapper.DMAPIImportTaskConfig) + + router.DELETE(options.BaseURL+"/api/v1/task/configs/:task-name", wrapper.DMAPIDeleteTaskConfig) + + router.GET(options.BaseURL+"/api/v1/task/configs/:task-name", wrapper.DMAPIGetTaskConfig) + + router.PUT(options.BaseURL+"/api/v1/task/configs/:task-name", wrapper.DMAPUpdateTaskConfig) + router.GET(options.BaseURL+"/api/v1/tasks", wrapper.DMAPIGetTaskList) router.POST(options.BaseURL+"/api/v1/tasks", wrapper.DMAPIStartTask) @@ -837,86 +954,89 @@ func RegisterHandlersWithOptions(router *gin.Engine, si ServerInterface, options // Base64 encoded, gzipped, json marshaled Swagger object var swaggerSpec = []string{ - "H4sIAAAAAAAC/+xd63PbOJL/V3C6+zAzJVmS7TiJr/aDY3uyvrOdlK2pua2pnAKBkIQ1CNAAaI825f99", - "Cw+SIAlSlB8Ze8b7Ycch8Wh0/7rRD4D61kM8TjjDTMne/reeREscQ/PnIU2lwuIM6v/XDxLBEywUweY1", - "jCLzNMISCZIowllv3zzFUgI+B2qJAUqFwEyB2AwCGI9wr9/Dv8M4obi33xtvv90abY22xvvvtvfGvX5P", - "rRL9XCpB2KJ31+9BSm5wfR7OKGEYSAVV6mYj0k3jz6BEivNRZ5xTDJkelmIY4QD9RPojmTW4ph0GZTA2", - "pBbrs8MEFnbX7wl8nRKBo97+b7Zntticur5l8pe8N5/9EyOlp3LC+ZWLqz9QODOesmgqeSoQnmarL89p", - "mgDbBOgmubBuDe31aeOVvKaDUduECi6ap9Iv105i2oZmqMvQDtFdhpr1ZUpDjAoKVWCo8ATKqwt8nWKp", - "6oIVOOY3eBpjBS0D5jClqrc/h1TifoUht0uslhrFHNh+QPcDEVRwBiUGhIGI3zKpBIZx/rgXgrZH+pQS", - "S9l/CTzv7ff+c1iYkKGzH8NL0/4cxvhUt77r9xSUV+t66aXX+Oov2Q0TYt4RplhhO+8FlglnEtf5p7t3", - "X4Wmp1jDXWDWYyG4+JWo5RmWMohKPTvUfwOs2/b6FYrM0ynSAK31Ne8AsuB1cxOm8AILPbntGstFU8/Y", - "EbUOusVAfZ+eEJs/YlXaGDRrmtmtMaX/SxSO5TpulzecgttQCLgy/+YKUiPFCisqy7Ht+nb29kVYA/r4", - "i3CG+YkXYdH+iNTbAb8P2Zdm735Uwu2QT02+tgqPyHNr9J6e5Mfldzorxvwe1E/gjOJLJVKkUtFi4C2B", - "U2S20qm8puXN/PDi+GByDCYHH06PwVc1/gp++Eqir4Aw9cN4/CM4/zQB57+cnoKDXyafpifnhxfHZ8fn", - "k/7ni5Ozg4t/gP89/oft8SMY/jT5j9+QVXccTQmL8O9fwOHpL5eT44vjI/DT8EdwfP7x5Pz4byeM8aMP", - "4Oj454NfTifg8O8HF5fHk7+lav4unu2Cw0+npweT4+zf0xlhIdfELa3uoUSzoLOkNMsCzc3z9f6M1z0b", - "y+NqSFSnHEYOEbUNqfDUKYcRSBlRta1wThiRSxxNZyvlnnARQ2Xhs7cb3AS1X6A5RvnCg1vBBe/9dKFI", - "FGyUCL7QrnHwpYHoBjRV+FhZVXk8b+ryUgKEh1j+yXgXOKQhuQdZCQKQcUYUB9YzwcDIFgjXoSYUmspl", - "yde04U951F8FUViasMLCVE9ggowlRlcJJ0wBqZ9ABY7OAILM4oAoAOc6+hBYKigUYQvTzbh5QUf0mk4R", - "ZwqzwNrkNQUrnoJbyJS3wpLnH7AA4CsaFyYg01JtBvrgK9pufrUTfvUAvf/voOKvGKov9pckghnPeaJI", - "TKQiCMglFJFmo8aPtqrglqiljYacaDijK5BKHIHbJWYAOtcUcIRSIXVY0DTm0dEpiEvuaC6aCup9OYWA", - "+zkVIW9ZYApXgPIFQHrYNAEJpwStAOJsThapdaXrTvTvCRFuG8tgOqpi1DSyrrgiNhDNp+v163rNUkq1", - "alQCfs/26D/Fjd3n8nl39ka1qSdLHW3ZxhqYCRaERwRBSldWRQCxQXnBACKBXVbUB25wcANpiveBmULL", - "SWLEWSTvR73AMSRsKhOIcGkF4zdV+s8II3Eag7nAGEREXgHTy9Dw8cN9pg8FUxd67YdG0HVkGGNi3uWC", - "q8OAmW3KvixMuWc+zKvqdlDbqawd+jg5OcpyJWniouTcPBcWBb+H4zna3h5gNHo3GI/x+8FsG6LBaHt3", - "G6LxeDQa7eyPB2/f7b5vZkyh7SUSw0mVnMQ5obhIqrSTafMqM8K2Rvp/291piYgo4aO3NbQv7BR1OUVE", - "YKS4WGkDI3Ad2FJxbSfWUtCIkvVuhq/aZZTYfJfnM5SHqPDQ8BgQZhFujU/B1B8qXB33wfj92/c/hsx4", - "ad4G8IUw9wCwtYMrTIJlXJYc1AQ9PgEIKrScpsk0zrPLjakr0xakid3Hcul4flOTmue4vT8+i3VvDWU6", - "M0OGduhwRjJjokVlabiLlDHdeZ0XXgZrEET+ckMSbmJ6RnZoe740nkKe+6rrmfUkjO0xmbR+ETeuD0wq", - "seIlRqkgalWfxvgvLnksJS17AX0jtznBNAK3hFIww2BJoggz69cssMr9SX+g0iBgLnhsmpj9ea73wrpZ", - "KhsQhIWaQkr5LY6miNXJPuRxzBk4d5b58vIU6D5kThC0Xn/OrLXMkZJOEWz2eb2BranKWvpoC2JWD6xX", - "0jj0z95weh2fj8+ANYPD/3szeu/+ri5t/axXeNU86WExn5ZKIsiNXtoVXmWWGHiTr5mv6pSWeRngQZ3A", - "oHY4f/ij4GkSyKRENE8vdxf0nAipppQju8uEuuhAAEebDaugWGAVbJqyzQesJQnM6P1izbWF5GR7EwaZ", - "anOPdVNjnzf4esUe1rESkkpsPTvthqfaahhTKa0hCO25bsT6LrPkQdNorYwrtoUraiHNSKCUt1xEjSPm", - "DcpD7uy+2QuOx0UzdealN87OzmgvFCMkWZjWlgy0sVyxuecefFsn39nX0Pb2gNbEY9auXJRqXKjLX3Ur", - "L9p9uq67D8k8pzLk3zjq9MsahYJztd6UeWt3SHQid1N6gOqXlKVZ91q2e69+27zd21aDbnu+z7am+XK/", - "KVQyW1/3sm6A5DFWS+0I3Aoe8rgy3MqcmLW4LcT9AAwKnFCCYAMWbdm5YeDJEmelbedj0hWw9W+Xd8ut", - "ZrWQPRhviC2fkCB2dDBquNIh52giVwCdt92Uc3yN0l9UlF7CSKfCui2PlkrrPgBrw4Vxx5PusOPJWtT9", - "IYso1dFqniTlMOpol7zii3eMpSJ1KK8ya1Tf/LpbsnvEv4sc/S617+13aTgSto5jx+Vfrhgqlm/KS+Hl", - "61fAzOTTYFLs/ZCLLLDk9AZHU+PhcnQ1baghtRrs7BxSkH/hg0TNVjjjt1tnEFcFO1pyZHrVIE0DpThn", - "2Oy4gcXONCcIW2iuhKbwCwa3S4KWeUKJSJB13igOrmXtOubXAtYSYaamKulaYXRJ9ukMLwmLvJRVl755", - "gBUoZel3rSsqtWhekS0o4pvsEGcHumyX7jzw9GChg942mdsGFbFDgUHKBtkovuhb1boUaa+NRn1G+Iss", - "Sb3fLalWFk9QGFU9CPHJC399pWqCVUiZTWX3obm4pqp/XdMm7qRe3Xg2mYk5oZp/IqXYnT4luhekn0ut", - "152C+UDYKV/8bAa70GOF0v+YLSFDeGpPAE+z8x5LyBZ4bZnaywPYkAjINNFRE5hze9rXHSyOIgoSmi4I", - "63Lw15TqLSVlFyyKB+7cYiWvWT92aSjQHldWu22sORSDNp5ebd72fUDIq3Csxtk0Sk1sogKjLfmt5t8S", - "ssimB+eUIIUjsxITa6axVkZ+g8WtILb8bo4+fglt8VrBp3Hw+KOWxy1cmSIA59oOQIX1luLNkmApXZm6", - "1+8VNevwZHZL7ZagMH6Z6VBkKewxmJgsBFQ4x3uV2xpXrg0wbfrdT4IZXT+znSs6UEnpbbCMielwBBX8", - "ACXOTuM2cD2j3NX5M0bPU0r1QhgSOMbMntqC1JwEKkAFTaNO/k1BwhqlrgCyuv6gVKqyDpvVgMkJJcEV", - "NkqpB5YAqqwwSPENpjWTSBaMC2w3oUB+Qj/O3M8cFC1tSqwFUUy7WHBHgzv9Vj8jk0ClsDCRkTXdzcQ0", - "NS/o+v8jwZP1VN01SODnlFKHd61ngSCiVK7hc6CRmOuXRlE9Q4Q4k0QqzFCgqGTMCVOCU5BZGMKcu2Lq", - "RPbkBRfaqM3NAex8NAClTIXGalk2qeIhFujhwmVIbel1UBQRUTfNW8Ns/qkzqrWRbYOpWgoMo/LBl93q", - "bmMYZjto/iHOnFcWdPVI3DjyeC84tO2xdugmBJwwJDZDgGeEGgAgcEKnM6hQ+ejauH40xx9Le2pLwRn5", - "Vz6VGQPg3zFKzSOtD9cpZIqYqcLnahLakX3Vhdybh83eYb75t/qGTa5AyDcsNsV6wqISqhRTjHbmaLS9", - "tzPYfofeDsZj/HYA997sDPbQaPZuN3rzfr4z2h8P3o52x7vbO/3Rm923u9EO8pq/23mzPdge7USz7d29", - "KNqJ9seD8dtR8JpQOS3nXfsxL9xRjZaeCS9zaDcY2z1N6rclGdu0i5XclAZSBgJTqC1a+0k6rdD5Voqc", - "jNf5F1Ubfmf9hI3HqVqCssvWyOTqijo7Wx6S14WWPh1NYqj5bs1ni6yTqLh/Act3GWXHUKtijc1LM0CG", - "vIC269fdtF22lmQ7IsqPixrC1j64JTRCUERZPFYOeGaDnx6YsawVqZoymcrmucNOfQdaVZDW1gKLY1A2", - "dwhdRRG/KY58TGFEHEvAuMqD42zFsiKW8T052HECNetgHtcxL8j6FhUuRUotDC8C93aOv8RDApudEbhP", - "6f6JquLtdfCQ0CtFnLbEfYsD1VxarRvVYsbGwpWrUEmQKbXirtwr26pW68oO9ygFtxd/70wgomNDSI84", - "CoSPR2fgU4LZwecTcPTpUMtE0N5+b6lUIveHw4gjuZUQtkAw2UI8Hv5rOVQkmg20cg3shkg4G0qr3cav", - "mHOTBCfKrKQ2wQ0W0s79Zmtna2TyWQlmMCG9/d6O1iwDCbU01A5hQoY346G7xzW0WVjzyhnc/P7uSWSm", - "O/h8EroDa1LM9lKa6b09GrlANDvmBhObwdDr+ae0J7wKc9ymOK13bo0QKmqUIqStyl2/t/uIZNTuOgem", - "nkNCcWRgJNM4hmLV29ecBI7B/scGMn1ScCE11lyT3hfdu0Eww2/2D7N/31m8UWzTlAFJfZrPKWHYsu3c", - "5poSKGCMrZR/qyW/PPIyD0o/14DpZfnVnkdDz9cXmx8uuNnlQxBfasDZDRjGZyZRbvla+XREJ0Fmdqyj", - "hhUXtL+PhgUuhL8wDfM+ebGRhjnBDL+5zWEjDXObWgcN88lr1jCPhr+2hpU/YNIqyCjeyogLatZHrI44", - "+p/LT+cNqlQmS4+VHyavwy3iCJjpCqoijioUOZ+ghZy/T85OO5GjG64hZ6lseryJHOterjc9xWcV1oFZ", - "z+ycVnM7JT+waCB9nWKx8jBN1HKatwhgOFxeDOD3UQ1f4CMSAZD6FyhodtypIoJqk0IUWdRlIg7ZxHr7", - "/ZvL7OSi84I/8Gj1aOvNPnBRX6CbDcz0dHc1lo+/AwnPzQbZ6/6A4VtftiGx1pVs+M1LtKzfRvyv96xV", - "Ospn5uJsysh1Wr7b07yjlPM+nXaUxpPid/1a5o3b88o8sXl8SKU7dZidqjRhnKtVhKyDGeGBdmH30TAT", - "/JrSC4CsBRmADwXsMIGptBlOY3xarNZn3fIiu4/8zIH7pctW+9yEamThHU2ep8ye7M0O7TxU2ALLNO4m", - "7QvT9FXcTyhuK42nlLf3lcsOjqC9C9vFHXwC4TbfqXlSv7By//eFhMDZtSFbzGjyQbvCY/jN/lG4MB3A", - "YmqAzw8r/ZaCT8P0xdo7Th+sBz0pSssHY18WSG097P4YVVCoTjtWcT/rpWxYTxD21e6o3ZUrHZrYu5e4", - "WbpjzE+5WebXSLrslfmNzecDtNbDNt8luVL59OILMVT+N6L9D20/BqR40tF2uTt+f2XTVbnm+GexXBGR", - "T226lIBMzt0H0ptRNnHNXkz66YmgVj+Z8GfBWgaE3PniANqP2dn6yhp02bzduh0w+y7wExcqa58fDjDB", - "5CCp+/L689lQcqoKdtvvubfXBYz3NrH3z54C9/Xv7v+R9QH3EfyXUh2A9jcXhMq/2VqWbFWNht/MafNN", - "ygJO9BtZZf/OW8Ac5zR0NMZNJ+QDgXXgUymBdH/tBxX8eR/0bZWXWe/OEvcGTa6KshmYbMq+S7L+OePp", - "y1PWPf1Uyd3LrQTcAxs2p9wpt/+KjpeKDlc4uAc8HlgmyAsEH1YaPQcsul8o8Rw2rdfCxR/lGbdWLx6M", - "4g2rGXkd4xXSr/WVF6tLwSLLI6uS7jejeMOIxv+tjledemY61W++vNbE8gwBnXne8Bs8Lzl4q2ue9CBe", - "y/is339eNeRVQ753xa7lx8Ze7AbYqoZJ2qSG+Y9LvarixpP/VRTx8ZMRa3/S7M9SlCp+f20DfW33Wrsd", - "1fC+OPtXyqpvlAH7DrvMCz0VYtCaoaeKTvM5AHGToal823vF062Ix5Awc9e7p5nsBmj80Yf26+URRw+8", - "Uz68Tgm6GtjjdLakNZD5r+CWYNULGVv3LePvQqQjL387UO6nYz31CxCZXRbM22UP7r7c/TsAAP//p/gb", - "xQCAAAA=", + "H4sIAAAAAAAC/+w961PjOJ7/ii53H2amEpIATXdztR9oYHq5A7oLMjW3NdWXVmwl0WJLRpJhsl3871t6", + "2JZtyXZ4NZlmP+zQtiz99Hu/pHzrBTROKEFE8N7+tx4PliiG6s/DKOUCsTMo/18+SBhNEBMYqdcwDNXT", + "EPGA4URgSnr76iniHNA5EEsEgpQxRASI1SSA0BD1+j30J4yTCPX2e+Ptt1ujrdHWeP/d9t641++JVSKf", + "c8EwWfTu+j0Y4RtUX4eSCBMEuIAiNathbpaxVxAsRfmsM0ojBImcNkIwRA74MbdnUnswQztMSmCsQC32", + "p6dxbOyu32PoOsUMhb39P/SX2WZz6PoayV/yr+nsnygQcilDnN8pu/qOxJnRlIRTTlMWoGm2+/KaagjQ", + "Q4AckhPrVsFeXzZe8etoMGpaUMCFfyn5snURNda1Qp2GeoruNJSoL0PqQpSTqAxBgSaQX12g6xRxUScs", + "QzG9QdMYCagRMIdpJHr7cxhx1K8g5HaJxFJyMQX6OyC/AyEUcAY5ApiAkN4SLhiCcf6452JtC/RphDVk", + "/8XQvLff+89hoUKGRn8ML9X4cxijUzn6rt8TkF+1fSW3XsOrvWUzjQt5RyhCAul1LxBPKOGojj/5efdd", + "SHiKPdw5Vj1mjLLfsVieIc6dXClXh/JvgOTYXr8CkXo6DSSD1r5V70CgmdesjYlAC8Tk4vrTmC98X8YG", + "qDbWLSbq2/C40PwRiZJhkKjxo1vylPwvFijmbdguG5wC25AxuFL/pgJGiooVVFS2o8f19erNm9AK9PE3", + "YRTzE29Cc/sjQq8nfB6wL5XtflTA9ZRPDb7UCo+Ic630nh7kx8V3OivmfA7oJ3AWoUvB0kCkrEHBawCn", + "gTKlU34dlY354cXxweQYTA4+nB6Dr2L8Ffz0FYdfASbip/H4Z3D+aQLOfzs9BQe/TT5NT84PL47Pjs8n", + "/c8XJ2cHF/8A/3v8D/3Fz2D4y+Q//gi0uKNwikmI/vwCDk9/u5wcXxwfgV+GP4Pj848n58d/OyGEHn0A", + "R8e/Hvx2OgGHfz+4uDye/C0V83fxbBccfjo9PZgcZ/+ezjBxuSZma3UPJZw5nSUhUeYYrp63+zPW59lc", + "FlZdpDqlMDQcUTNIhaceURiClGBRM4VzTDBfonA6WwnzhLIYCs0+e7tOIyj9AomxiC4sdiuwYL2fLgQO", + "nYMSRhfSNXa+VCy6BkwVPFZ2VZ7PWrq8FQfgLpR/Ut4FcklI7kFWgoBAOSOCAu2ZIKBoC5j5oEaUKOXL", + "kq+pw5/yrL8zLBBXYYVmU7mACjKWKLhKKCYCcPkECnB0BgJINB9gAeBcRh8McQGZwGShPlNuntMRvY6m", + "ASUCEcfe+HUEVjQFt5AIa4clz9+hAcDXYFyogExKpRrog6/Btv/VjvvVA+T+v52CvyJBfbO/JSHMcE4T", + "gWPMBQ4AX0IWSjRK/pFaFdxisdTRkCENJdEKpByF4HaJCIDGNQU0CFLGZVjgm/Po6BTEJXc0J02F6206", + "uRj3c8pc3jJDEVyBiC5AIKdNE5DQCAcrEFAyx4tUu9J1J/rPBDNjxjI2HVV5VA3SrrjAOhDNl+v163JN", + "0iiSolEJ+C3dI/9kN9rO5evu7I1qS0+WMtrSgyVjJohhGuIARtFKiwjAOigvEIA50NsK+8BMDm5glKJ9", + "oJaQdOIooCTk94OeoRhiMuUJDFBpB+M3VfjPMMFxGoM5QwiEmF8B9ZWC4eOH+yzvCqYu5N4PFaHrnKGU", + "iXqXE67OBkSZKf2yUOWW+lCvquagZqm0Hvo4OTnKciVpYqLkXD0XGgW9h+N5sL09QMHo3WA8Ru8Hs20Y", + "DEbbu9swGI9Ho9HO/njw9t3uez9iCmkvgehOquQgznGEiqRKM5g6rzLDZGsk/7fdHZYQsxJ/9LaG+oVe", + "ok6nEDMUCMpWUsEwVGdsLqjUE60QeLmk3c2wRbvMJTrfZfkM5SkqOFQ4BphoDtfKp0DqTxWsjvtg/P7t", + "+59dary0rof5XDz3AGZrZi43CBpxWXJQAvT4AARQBMtpmkzjPLvsTV2psSBNtB3LqWP5TT4xz/n2/vxZ", + "7HtryNOZmtJlod0ZyQyJmitL012khMiP27zwMrM6mcjerovCPqRnYLvM86XyFPLcV13OtCehdI/KpPWL", + "uLE9MKnEipcoSBkWq/oyyn8xyWPOo7IX0Fd0m2MUheAWRxGYIbDEYYiI9msWSOT+pD1RaRIwZzRWQ5R9", + "nktbWFdLZQUSICamMIroLQqnAamDfUjjmBJwbjTz5eUpkN/gOQ6g9vpzZLUih/NoGkC/z2tNrFVVNtLm", + "NifPyonlTrxT/2pNJ/fx+fgMaDU4/L83o/fm7+rW2le9Qiv/oofFepIqCcM3cmtXaJVpYmAt3rJe1Skt", + "49KBgzqATukw/vBHRtPEkUkJozy93J3Qc8y4mEY00FbG9YkMBFC43rQCsgUSzqEpWX/CWpJAzd4v9lzb", + "SA62taATqTr3WFc1+rnH1ytsWMdKSMqR9uykG55KraFUJdeKwGVzzYx1K7OkTtWotYwptrkrai7JSCDn", + "t5SF3hnzAeUpd3bf7Dnno8wPnXppzbOzM9pzxQhJFqY1JQN1LFcY99yDb/rIdvYla1s2oDHxmI0rF6W8", + "GzX5q27lRW2n67L7kMxzyl3+jYFOvqxByCgV7arM2rvhRENys6TFUP2SsPhlr8HcW/Vbv7nXowbdbL6N", + "Nt96ud/kKpm11720G8BpjMRSOgK3jLo8roxveQ5MK98W5H4ADzKURDiAHl7UZWfPxJMlykrbxseMVkDX", + "v03eLdea1UL2YLwmb9mAOHlHBqMKKx1yjipyBdB4276c42uUvlFReolHOhXWdXm0VFq3GbA2nZvvaNKd", + "7WjSynXfZROlOlrNk4woDDvqJav4YrWxVKgO+VWmjerGr7smu0f8u8i536T2LXuXuiNh7Th23P7ligTF", + "9lV5yb19+QqolWwYVIq973KRGeI0ukHhVHm4NLiaempIjQo760Ny4s/dSOTXwhm+zT6dfFWgoyFHJncN", + "0tRRijOKTc/r2OxMYgKThcSKawm7YHC7xMEyTyhhDrKP14qDa1m7jvk1h7YMEBFTkXStMJok+3SGlpiE", + "Vsqqy7d5gOUoZcl3jTsqjfDvSBcU0U3WxNkBLv1JdxxYcrCQQW8TzfWACtkhQyAlg2wWm/SNYl2KtFuj", + "URsR9iZLVO93S6qVyeMkRlUOXHiywl9bqHxs5RJmVdl9aC7OV/WvS9rEdOrVladPTcxxJPHH0giZ7lMs", + "v4LR59Loti6YD5ic0sWvarILOZcr/Y/IEpIATXUH8DTr91hCskCtZWorD6BDIsDTREZNYE51t69pLA7D", + "CCRRusCkS+OvKtVrSMouWBgPTN9iJa9Zb7tUEEiPK6vdemsOxaTe7lW/2bcZgl+5YzVKpmGqYhPhmG1J", + "byX+lpCEOj04j3AgUKh2omLNNJbCSG8Qu2VYl99V6+MXl4mXAj6Nne2Pkh63cKWKAJRKPQAFkibFWiVB", + "nJsyda/fK2rW7sW0Se2WoFB+mfqgyFLoNpgYLxgUKOf3KrYlX5kxQI3pd+8EU7J+pj+uyEAlpbfGNibq", + "gyMo4AfIUdaN68F6Brmp82eInqdRJDdCAoZiRHTXFoxUJ1DBVFAN6uTfFCC0CHWFIav7d1KlSmu3WnWo", + "HFcSXCAllHJiDqDICoMRukFRTSXiBaEMaSPkyE/Ix5n7mTNFw5gSakEYR100uIHBdL/Ve2QSKARiKjLS", + "qtsPjG94Adf/HzGatEN156GAFi5vw3uhRdZJ8uZfqWgj6xsQKE4iw0LN3SvFql9awPb1Ic4hjlA4VUxe", + "yyc2pLMcXXymY93xtpaMz4baveGuHdSKTGkQIM494K5XEqjP1a9jw4fWX9MoMtpPYtgRUpaKd3QOpF7K", + "ta1coJ4vDCjhmAtEAkeJURkXIhiNQGZvMDHOq6oa6j4cyqSJm6t2/Hw2ADlPmdRcZUlNBXUJhJzOXZSW", + "dl+GyCFmdUO9NczWnxoTW5tZD5iKJUMwLLdB7VbFRCFMfyDxF1BifHSn449j78zjPefU+ovWqX364IQE", + "bD0OsEyShwEYSqLpDIqg3Mg4rjdq2XNJv33JKMH/ypdScwD0JwpS9Uhqx+sUEoHVUu4uqyTqiL7qRu6N", + "Q3+skLuCjZGCzzF0RQqFi1TXbJXAtVhitDMPRtt7O4Ptd8HbwXiM3g7g3pudwV4wmr3bDd+8n++M9seD", + "t6Pd8e72Tn/0ZvftbrgTWMPf7bzZHmyPdsLZ9u5eGO6E++PB+O3IeWisnKS1DoGpF6Zxp+HLhJYxtOuM", + "9J+mENCQmvfp0JLT6gFlwJC0hGFLX6UU6NyxCgyN27zNqg6/017j2vNUNUHZgfciubqjzq63xcmtNs6C", + "w0eGmifv7zTTIYOg9nE8O4DgHQPvijZWL9UEGec5pF2+7ibtvLFA35Gj7CjZk8Tog1schQFkYRadl8Pf", + "2eCXB+avayVLX15b6KqHO8TrAKtwwtpYbjMIytZ2em95S4cvq/CYxAgp4oBQkadKsh3zClnG98RgxwXE", + "rIN6bEOeE/UNIlyKmxsQXqRxmjG+iS0j63WM3KeR44l6JJq7IlxEr5T0mso4DQ6Uv9BeV6rFit4ypqlX", + "cpAJtaCm+M+baphtRah7NAY0twLcqUBESGpFRzRwJBOOzsCnBJGDzyfg6NOhpAmLevu9pRAJ3x8OQxrw", + "rQSTRQCTrYDGw38thwKHs4EUroE2iJiSIdfSrfyKOVURKhZqJ7UFbhDjeu03WztbI5XdTBCBCe7t93ak", + "ZCmWEEsF7RAmeHgzHppTfUOdk1evjMLNT3OfhGq5g88nrhPRquCgUwPq6+3RyASiWdMjTHQ+S+7nn1z3", + "+xXquElwGk9gKyJUxEjH43Lru48IRu3ku2NpHfYrNuJpHEO26u1LTAKDYPvqiUyeBFxwyWtmSO+L/NpD", + "mOE3/Yey33ea3yKkc0UOSn2azyNMkEbbuc48JpDBGGkq/1FLhVrgZR6UfC4Zppdl23sWDD1bXnS1oMBm", + "l2tBvtQYZ9ehGF8YRanGa+UikU6EzPRYRwkrjus/j4Q5rgfYMAmzLkBZS8IMYYbfjHFYS8KMUesgYTZ4", + "fgmzYPixJax8nU0jIcN4KwPOKVkfkTiiwf9cfjr3iFIZLDlXfrSgzm4hDYBaroAqpEEFIuMTNIDz98nZ", + "aSdw5MAWcJZCF0t84Gj3sl31FJdstDGzXNk4reqsUt6+qlj6OkVsZfE0FstpPsLBw+5is4N/H1XxOa4U", + "cTCpfZwmyprfKiSoDilIkUVdKuLgPtTr25Ausz5W4wV/oOHq0fabXXdS36BZDczkcnc1lI+fAYSXpoP0", + "5Q+AoFubti6y1oVs+M1KtLSbEfsup1ahi+hMHaNOCb5Oyye9/BalnPfpZFG85wbu+rXMG9Xd6zTReXwY", + "cdODmvXYqjDO1Cpc2kHN8EC9sPtoPOO8W2sDWFYzGYAPZdhhAlOuM5xK+TRorc9y5EV2Ov2FM+6XLqb2", + "pRFV0cJqVJ+nRPd5Zy1cDyU2QzyNu1H7Qg19JfcTkltT4ynpbd152sER1Ceju7iDT0Bc/wmrJ/ULK6fB", + "NyQEzg6R6WKGzwftyh7Db/qPwoXpwCyqBvjyeKXfUPDxLF/svePyznrQk3JpuU16s5hU18Puz6MCMtHJ", + "YhWn9TbFYD1B2Fc7sXhXrnRIYO820ViapvanNJb5oaIutjI/v/tyGK2x2eZZkiuVizg3RFHZN4bb164/", + "BkvRpKPuMic+f2TVVTn0+lfRXCHmT626BIOEz811+X4um5hhG5N+eiJWq3cm/FV4LWOE3PmiAOqrDXV9", + "pYW7BORXQ93m024Ii7MCz1C1rN1M7cCISkhG5lL+l2NdrGMaFS9Y3/jfpVZQ4PqJ6gXm9wm+X7XAB8AL", + "rRVYVK0T1CNRQ31+oEVJn6hBz0Lw8gGl9am//STQbI7zaM6D3IsXvqmzCOsUjUossZbltk/JOkx2DklH", + "g+07RbGZDQimkqIOcPmI2O9qCTeHMqMfTnNnxriByknqobK+kfyVzptA51TRqpnUFa3czdl9dXPb3Nx7", + "+LcqYznRN3A8hZ9T/+WxVy+3s5cL9a/OGR+nXYzu6dW8VG3a73JZpKPFpfaTcva6D7pdcqNdLM1NpnNo", + "PWbSbSpdGlReMj99ecpeP7s8eLe53S/34A3dR9Gpn+WVOzaVO0yzzD3Y44GtMXlTzIeV5J4DEt4vff4S", + "jNZrs8738owbO3YezMVrdvDkvTuvLP3aU7SxsuRsLHpkUZLfzSK0ZkRj/1rhq0y9MJnq+y9s8KE844DO", + "OPf8Cumm58fLksctFl83X/4qIa8S8h261Bp+bnljDWCjGHoLGif5z+u+iuLai/8ogvj4yYjWH3X+qzRi", + "Fb9AvYa8Nnut3dqTrd/c+JGy6mtlwJ7BymxoJ7Ti1ox7qtyprsBiNxk3lW84WtF0K6QxxETdb9STSDYT", + "eH/2rvlKpZAGD7xHaXid4uBqoI+Q6JLWwCx+V2GrnkvZml9zeRYgDXj524Fa/q4kfg4gswsy8nHZg7sv", + "d/8OAAD//7mGQmsCjQAA", } // GetSwagger returns the content of the embedded swagger specification file diff --git a/dm/openapi/gen.types.go b/dm/openapi/gen.types.go index 4d5cea78df4..b9e0e80806b 100644 --- a/dm/openapi/gen.types.go +++ b/dm/openapi/gen.types.go @@ -395,6 +395,21 @@ type TaskBinLogFilterRule struct { IgnoreSql *[]string `json:"ignore_sql,omitempty"` } +// TaskConfigRequest defines model for TaskConfigRequest. +type TaskConfigRequest struct { + // whether to overwrite task config template + Overwrite bool `json:"overwrite"` +} + +// TaskConfigResponse defines model for TaskConfigResponse. +type TaskConfigResponse struct { + FailedTaskList []struct { + ErrorMsg string `json:"error_msg"` + TaskName string `json:"task_name"` + } `json:"failed_task_list"` + SuccessTaskList []string `json:"success_task_list"` +} + // configuration of full migrate tasks type TaskFullMigrateConf struct { // to control the way in which data is exported for consistency assurance @@ -522,6 +537,12 @@ type DMAPIStopRelayJSONBody StopRelayRequest // DMAPITransferSourceJSONBody defines parameters for DMAPITransferSource. type DMAPITransferSourceJSONBody WorkerNameRequest +// DMAPICreateTaskConfigJSONBody defines parameters for DMAPICreateTaskConfig. +type DMAPICreateTaskConfigJSONBody Task + +// DMAPIImportTaskConfigJSONBody defines parameters for DMAPIImportTaskConfig. +type DMAPIImportTaskConfigJSONBody TaskConfigRequest + // DMAPIStartTaskJSONBody defines parameters for DMAPIStartTask. type DMAPIStartTaskJSONBody CreateTaskRequest @@ -558,6 +579,12 @@ type DMAPIStopRelayJSONRequestBody DMAPIStopRelayJSONBody // DMAPITransferSourceJSONRequestBody defines body for DMAPITransferSource for application/json ContentType. type DMAPITransferSourceJSONRequestBody DMAPITransferSourceJSONBody +// DMAPICreateTaskConfigJSONRequestBody defines body for DMAPICreateTaskConfig for application/json ContentType. +type DMAPICreateTaskConfigJSONRequestBody DMAPICreateTaskConfigJSONBody + +// DMAPIImportTaskConfigJSONRequestBody defines body for DMAPIImportTaskConfig for application/json ContentType. +type DMAPIImportTaskConfigJSONRequestBody DMAPIImportTaskConfigJSONBody + // DMAPIStartTaskJSONRequestBody defines body for DMAPIStartTask for application/json ContentType. type DMAPIStartTaskJSONRequestBody DMAPIStartTaskJSONBody diff --git a/dm/openapi/spec/dm.yaml b/dm/openapi/spec/dm.yaml index 1c9839e28ae..160642c8aeb 100644 --- a/dm/openapi/spec/dm.yaml +++ b/dm/openapi/spec/dm.yaml @@ -723,6 +723,149 @@ paths: "application/json": schema: $ref: "#/components/schemas/ErrorWithMessage" + /api/v1/task/configs: + post: + tags: + - task + summary: "create task config" + operationId: "DMAPICreateTaskConfig" + requestBody: + description: "request body" + content: + "application/json": + schema: + $ref: "#/components/schemas/Task" + responses: + "201": + description: "success" + content: + "application/json": + schema: + $ref: "#/components/schemas/Task" + "400": + description: "failed" + content: + "application/json": + schema: + $ref: "#/components/schemas/ErrorWithMessage" + get: + tags: + - task + summary: "get task config list" + operationId: "DMAPIGetTaskConfigList" + responses: + "200": + description: "task list" + content: + "application/json": + schema: + $ref: "#/components/schemas/GetTaskListResponse" + "400": + description: "failed" + content: + "application/json": + schema: + $ref: "#/components/schemas/ErrorWithMessage" + /api/v1/task/configs/import: + post: + tags: + - task + summary: "import task config" + operationId: "DMAPIImportTaskConfig" + requestBody: + description: "request body" + content: + "application/json": + schema: + $ref: "#/components/schemas/TaskConfigRequest" + responses: + "202": + description: "success" + content: + "application/json": + schema: + $ref: "#/components/schemas/TaskConfigResponse" + "400": + description: "failed" + content: + "application/json": + schema: + $ref: "#/components/schemas/ErrorWithMessage" + /api/v1/task/configs/{task-name}: + get: + tags: + - task + summary: "get task_config" + operationId: "DMAPIGetTaskConfig" + parameters: + - name: task-name + in: path + description: "globally unique task name" + required: true + schema: + type: string + example: "task-1" + responses: + "200": + description: "success" + content: + "application/json": + schema: + $ref: "#/components/schemas/Task" + "400": + description: "failed" + content: + "application/json": + schema: + $ref: "#/components/schemas/ErrorWithMessage" + put: + tags: + - task + summary: "update task_config" + operationId: "DMAPUpdateTaskConfig" + parameters: + - name: task-name + in: path + description: "globally unique task name" + required: true + schema: + type: string + example: "task-1" + responses: + "200": + description: "success" + content: + "application/json": + schema: + $ref: "#/components/schemas/Task" + "400": + description: "failed" + content: + "application/json": + schema: + $ref: "#/components/schemas/ErrorWithMessage" + delete: + tags: + - task + summary: "delete task_config" + operationId: "DMAPIDeleteTaskConfig" + parameters: + - name: task-name + in: path + description: "globally unique task name" + required: true + schema: + type: string + example: "task-1" + responses: + "204": + description: "success" + "400": + description: "failed" + content: + "application/json": + schema: + $ref: "#/components/schemas/ErrorWithMessage" /api/v1/cluster/masters: get: @@ -1504,6 +1647,7 @@ components: required: - "remove_meta" - "task" + OperateTaskTableStructureRequest: description: action to operate table request type: object @@ -1617,3 +1761,35 @@ components: required: - "total" - "data" + + TaskConfigRequest: + type: object + properties: + overwrite: + type: boolean + default: false + description: whether to overwrite task config template + required: + - "overwrite" + TaskConfigResponse: + type: object + properties: + success_task_list: + type: array + items: + type: string + failed_task_list: + type: array + items: + type: object + properties: + task_name: + type: string + error_msg: + type: string + required: + - "task_name" + - "error_msg" + required: + - "success_task_list" + - "failed_task_list"