From f5e7da3cf667ff2d7a6323d2ae2126881b4a2fe2 Mon Sep 17 00:00:00 2001 From: JinYong Li <42576980+JinyLeeChina@users.noreply.github.com> Date: Tue, 16 Nov 2021 20:38:49 +0800 Subject: [PATCH] [Improvement][API] add interface method (#6863) * upgrade add sub_process * add interface method * add interface method * fix ut --- .../ProcessDefinitionController.java | 138 ++++++++++ .../ProcessTaskRelationController.java | 244 ++++++++++++++++++ .../api/controller/SchedulerController.java | 43 +++ .../controller/TaskDefinitionController.java | 29 +++ .../dolphinscheduler/api/enums/Status.java | 4 + .../api/service/ProcessDefinitionService.java | 74 ++++++ .../service/ProcessTaskRelationService.java | 126 +++++++++ .../api/service/SchedulerService.java | 25 ++ .../api/service/TaskDefinitionService.java | 14 + .../impl/ProcessDefinitionServiceImpl.java | 82 ++++++ .../impl/ProcessTaskRelationServiceImpl.java | 151 +++++++++++ .../service/impl/SchedulerServiceImpl.java | 28 ++ .../impl/TaskDefinitionServiceImpl.java | 18 +- 13 files changed, 975 insertions(+), 1 deletion(-) create mode 100644 dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/ProcessTaskRelationController.java create mode 100644 dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessTaskRelationService.java create mode 100644 dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessTaskRelationServiceImpl.java diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/ProcessDefinitionController.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/ProcessDefinitionController.java index 67e575f5d6..ec7c5f9abb 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/ProcessDefinitionController.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/ProcessDefinitionController.java @@ -699,4 +699,142 @@ public class ProcessDefinitionController extends BaseController { Map result = processDefinitionService.importProcessDefinition(loginUser, projectCode, file); return returnDataList(result); } + + /** + * create empty process definition + * + * @param loginUser login user + * @param projectCode project code + * @param name process definition name + * @param description description + * @param globalParams globalParams + * @param timeout timeout + * @param tenantCode tenantCode + * @param scheduleJson scheduleJson + * @return process definition code + */ + @ApiOperation(value = "createEmptyProcessDefinition", notes = "CREATE_EMPTY_PROCESS_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "name", value = "PROCESS_DEFINITION_NAME", required = true, type = "String"), + @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", required = true, dataType = "Long", example = "123456789"), + @ApiImplicitParam(name = "description", value = "PROCESS_DEFINITION_DESC", required = false, type = "String") + }) + @PostMapping(value = "/empty") + @ResponseStatus(HttpStatus.OK) + @ApiException(CREATE_PROCESS_DEFINITION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result createEmptyProcessDefinition(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @RequestParam(value = "name", required = true) String name, + @RequestParam(value = "description", required = false) String description, + @RequestParam(value = "globalParams", required = false, defaultValue = "[]") String globalParams, + @RequestParam(value = "timeout", required = false, defaultValue = "0") int timeout, + @RequestParam(value = "tenantCode", required = true) String tenantCode, + @RequestParam(value = "scheduleJson", required = false) String scheduleJson, + @RequestParam(value = "executionType", defaultValue = "PARALLEL") ProcessExecutionTypeEnum executionType) { + return returnDataList(processDefinitionService.createEmptyProcessDefinition(loginUser, projectCode, name, description, globalParams, + timeout, tenantCode, scheduleJson, executionType)); + } + + /** + * update process definition basic info + * + * @param loginUser login user + * @param projectCode project code + * @param name process definition name + * @param code process definition code + * @param description description + * @param globalParams globalParams + * @param timeout timeout + * @param tenantCode tenantCode + * @param scheduleJson scheduleJson + * @param executionType executionType + * @param releaseState releaseState + * @return update result code + */ + @ApiOperation(value = "updateBasicInfo", notes = "UPDATE_PROCESS_DEFINITION_BASIC_INFO_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "name", value = "PROCESS_DEFINITION_NAME", required = true, type = "String"), + @ApiImplicitParam(name = "code", value = "PROCESS_DEFINITION_CODE", required = true, dataType = "Long", example = "123456789"), + @ApiImplicitParam(name = "description", value = "PROCESS_DEFINITION_DESC", required = false, type = "String"), + @ApiImplicitParam(name = "releaseState", value = "RELEASE_PROCESS_DEFINITION_NOTES", required = false, dataType = "ReleaseState") + }) + @PutMapping(value = "/{code}/basic-info") + @ResponseStatus(HttpStatus.OK) + @ApiException(UPDATE_PROCESS_DEFINITION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result updateProcessDefinitionBasicInfo(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @RequestParam(value = "name", required = true) String name, + @PathVariable(value = "code", required = true) long code, + @RequestParam(value = "description", required = false) String description, + @RequestParam(value = "globalParams", required = false, defaultValue = "[]") String globalParams, + @RequestParam(value = "timeout", required = false, defaultValue = "0") int timeout, + @RequestParam(value = "tenantCode", required = true) String tenantCode, + @RequestParam(value = "scheduleJson", required = false) String scheduleJson, + @RequestParam(value = "executionType", defaultValue = "PARALLEL") ProcessExecutionTypeEnum executionType, + @RequestParam(value = "releaseState", required = false, defaultValue = "OFFLINE") ReleaseState releaseState) { + Map result = processDefinitionService.updateProcessDefinitionBasicInfo(loginUser, projectCode, name, code, description, globalParams, + timeout, tenantCode, scheduleJson, executionType); + // If the update fails, the result will be returned directly + if (result.get(Constants.STATUS) != Status.SUCCESS) { + return returnDataList(result); + } + + // Judge whether to go online after editing,0 means offline, 1 means online + if (releaseState == ReleaseState.ONLINE) { + result = processDefinitionService.releaseWorkflowAndSchedule(loginUser, projectCode, code, releaseState); + } + return returnDataList(result); + } + + /** + * release process definition and schedule + * + * @param loginUser login user + * @param projectCode project code + * @param code process definition code + * @param releaseState releaseState + * @return update result code + */ + @ApiOperation(value = "releaseWorkflowAndSchedule", notes = "RELEASE_WORKFLOW_SCHEDULE_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROCESS_DEFINITION_NAME", required = true, type = "Long"), + @ApiImplicitParam(name = "code", value = "PROCESS_DEFINITION_CODE", required = true, dataType = "Long", example = "123456789"), + @ApiImplicitParam(name = "releaseState", value = "RELEASE_PROCESS_DEFINITION_NOTES", required = true, dataType = "ReleaseState") + }) + @PostMapping(value = "/{code}/release-workflow") + @ResponseStatus(HttpStatus.OK) + @ApiException(RELEASE_PROCESS_DEFINITION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result releaseWorkflowAndSchedule(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @PathVariable(value = "code", required = true) long code, + @RequestParam(value = "releaseState", required = true, defaultValue = "OFFLINE") ReleaseState releaseState) { + return returnDataList(processDefinitionService.releaseWorkflowAndSchedule(loginUser, projectCode, code, releaseState)); + } + + /** + * delete process definition and schedule + * + * @param loginUser login user + * @param projectCode project code + * @param code process definition code + * @return update result code + */ + @ApiOperation(value = "deleteWorkflowAndSchedule", notes = "DELETE_WORKFLOW_SCHEDULE_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROCESS_DEFINITION_NAME", required = true, type = "Long"), + @ApiImplicitParam(name = "code", value = "PROCESS_DEFINITION_CODE", required = true, dataType = "Long", example = "123456789") + }) + @DeleteMapping(value = "/{code}/delete-workflow") + @ResponseStatus(HttpStatus.OK) + @ApiException(DELETE_PROCESS_DEFINE_BY_CODE_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result deleteWorkflowAndSchedule(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @PathVariable(value = "code", required = true) long code) { + return returnDataList(processDefinitionService.deleteWorkflowAndSchedule(loginUser, projectCode, code)); + } + } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/ProcessTaskRelationController.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/ProcessTaskRelationController.java new file mode 100644 index 0000000000..29b8be7b73 --- /dev/null +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/ProcessTaskRelationController.java @@ -0,0 +1,244 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.dolphinscheduler.api.controller; + +import static org.apache.dolphinscheduler.api.enums.Status.CREATE_PROCESS_TASK_RELATION_ERROR; +import static org.apache.dolphinscheduler.api.enums.Status.DELETE_TASK_PROCESS_RELATION_ERROR; +import static org.apache.dolphinscheduler.api.enums.Status.MOVE_PROCESS_TASK_RELATION_ERROR; +import static org.apache.dolphinscheduler.api.enums.Status.QUERY_TASK_PROCESS_RELATION_ERROR; + +import org.apache.dolphinscheduler.api.aspect.AccessLogAnnotation; +import org.apache.dolphinscheduler.api.exceptions.ApiException; +import org.apache.dolphinscheduler.api.service.ProcessTaskRelationService; +import org.apache.dolphinscheduler.api.utils.Result; +import org.apache.dolphinscheduler.common.Constants; +import org.apache.dolphinscheduler.dao.entity.User; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestAttribute; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.ResponseStatus; +import org.springframework.web.bind.annotation.RestController; + +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiImplicitParam; +import io.swagger.annotations.ApiImplicitParams; +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import springfox.documentation.annotations.ApiIgnore; + +/** + * process task relation controller + */ +@Api(tags = "PROCESS_TASK_RELATION_TAG") +@RestController +@RequestMapping("projects/{projectCode}/process-task-relation") +public class ProcessTaskRelationController extends BaseController { + + @Autowired + private ProcessTaskRelationService processTaskRelationService; + + /** + * create process task relation + * + * @param loginUser login user + * @param projectCode project code + * @param processDefinitionCode processDefinitionCode + * @param preTaskCode preTaskCode + * @param postTaskCode postTaskCode + * @return create result code + */ + @ApiOperation(value = "save", notes = "CREATE_PROCESS_TASK_RELATION_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "processDefinitionCode", value = "PROCESS_DEFINITION_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "preTaskCode", value = "PRE_TASK_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "postTaskCode", value = "POST_TASK_CODE", required = true, type = "Long") + }) + @PostMapping() + @ResponseStatus(HttpStatus.CREATED) + @ApiException(CREATE_PROCESS_TASK_RELATION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result createProcessTaskRelation(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @RequestParam(name = "processDefinitionCode", value = "PROCESS_DEFINITION_CODE", required = true) long processDefinitionCode, + @RequestParam(name = "preTaskCode", value = "PRE_TASK_CODE", required = true) long preTaskCode, + @RequestParam(name = "postTaskCode", value = "POST_TASK_CODE", required = true) long postTaskCode) { + return returnDataList(processTaskRelationService.createProcessTaskRelation(loginUser, projectCode, processDefinitionCode, preTaskCode, postTaskCode)); + } + + /** + * move task to other processDefinition + * + * @param loginUser login user info + * @param projectCode project code + * @param processDefinitionCode process definition code + * @param targetProcessDefinitionCode target process definition code + * @param taskCode the current task code (the post task code) + * @return move result code + */ + @ApiOperation(value = "moveRelation", notes = "MOVE_TASK_TO_OTHER_PROCESS_DEFINITION_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "processDefinitionCode", value = "PROCESS_DEFINITION_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "targetProcessDefinitionCode", value = "TARGET_PROCESS_DEFINITION_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "taskCode", value = "TASK_CODE", required = true, type = "Long") + }) + @PostMapping(value = "/move") + @ResponseStatus(HttpStatus.OK) + @ApiException(MOVE_PROCESS_TASK_RELATION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result moveTaskProcessRelation(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @RequestParam(name = "processDefinitionCode", value = "PROCESS_DEFINITION_CODE", required = true) long processDefinitionCode, + @RequestParam(name = "targetProcessDefinitionCode", value = "TARGET_PROCESS_DEFINITION_CODE", required = true) long targetProcessDefinitionCode, + @RequestParam(name = "taskCode", value = "POST_TASK_CODE", required = true) long taskCode) { + return returnDataList(processTaskRelationService.moveTaskProcessRelation(loginUser, projectCode, processDefinitionCode, + targetProcessDefinitionCode, taskCode)); + } + + /** + * delete process task relation + * + * @param loginUser login user + * @param projectCode project code + * @param processDefinitionCode process definition code + * @param taskCode the post task code + * @return delete result code + */ + @ApiOperation(value = "deleteRelation", notes = "DELETE_PROCESS_TASK_RELATION_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "processDefinitionCode", value = "PROCESS_DEFINITION_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "taskCode", value = "TASK_CODE", required = true, type = "Long") + }) + @DeleteMapping(value = "/{taskCode}") + @ResponseStatus(HttpStatus.OK) + @ApiException(DELETE_TASK_PROCESS_RELATION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result deleteTaskProcessRelation(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @RequestParam(name = "processDefinitionCode", value = "PROCESS_DEFINITION_CODE", required = true) long processDefinitionCode, + @PathVariable("taskCode") long taskCode) { + return returnDataList(processTaskRelationService.deleteTaskProcessRelation(loginUser, projectCode, processDefinitionCode, taskCode)); + } + + /** + * delete task upstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param preTaskCodes the pre task codes, sep ',' + * @param taskCode the post task code + * @return delete result code + */ + @ApiOperation(value = "deleteUpstreamRelation", notes = "DELETE_UPSTREAM_RELATION_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "preTaskCodes", value = "PRE_TASK_CODES", required = true, type = "String", example = "3,4"), + @ApiImplicitParam(name = "taskCode", value = "TASK_CODE", required = true, type = "Long") + }) + @DeleteMapping(value = "/{taskCode}/upstream") + @ResponseStatus(HttpStatus.OK) + @ApiException(DELETE_TASK_PROCESS_RELATION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result deleteUpstreamRelation(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @RequestParam(name = "preTaskCodes", value = "PRE_TASK_CODES", required = true) String preTaskCodes, + @PathVariable("taskCode") long taskCode) { + return returnDataList(processTaskRelationService.deleteUpstreamRelation(loginUser, projectCode, preTaskCodes, taskCode)); + } + + /** + * delete task downstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param postTaskCodes the post task codes, sep ',' + * @param taskCode the pre task code + * @return delete result code + */ + @ApiOperation(value = "deleteDownstreamRelation", notes = "DELETE_DOWNSTREAM_RELATION_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "postTaskCodes", value = "POST_TASK_CODES", required = true, type = "String", example = "3,4"), + @ApiImplicitParam(name = "taskCode", value = "TASK_CODE", required = true, type = "Long") + }) + @DeleteMapping(value = "/{taskCode}/downstream") + @ResponseStatus(HttpStatus.OK) + @ApiException(DELETE_TASK_PROCESS_RELATION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result deleteDownstreamRelation(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @RequestParam(name = "postTaskCodes", value = "POST_TASK_CODES", required = true) String postTaskCodes, + @PathVariable("taskCode") long taskCode) { + return returnDataList(processTaskRelationService.deleteDownstreamRelation(loginUser, projectCode, postTaskCodes, taskCode)); + } + + /** + * query task upstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param taskCode current task code (post task code) + * @return process task relation list + */ + @ApiOperation(value = "queryUpstreamRelation", notes = "QUERY_UPSTREAM_RELATION_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "taskCode", value = "TASK_CODE", required = true, type = "Long") + }) + @GetMapping(value = "/{taskCode}/upstream") + @ResponseStatus(HttpStatus.OK) + @ApiException(QUERY_TASK_PROCESS_RELATION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result queryUpstreamRelation(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @PathVariable("taskCode") long taskCode) { + return returnDataList(processTaskRelationService.queryUpstreamRelation(loginUser, projectCode, taskCode)); + } + + /** + * query task downstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param taskCode pre task code + * @return process task relation list + */ + @ApiOperation(value = "queryDownstreamRelation", notes = "QUERY_DOWNSTREAM_RELATION_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROJECT_CODE", required = true, type = "Long"), + @ApiImplicitParam(name = "taskCode", value = "TASK_CODE", required = true, type = "Long") + }) + @GetMapping(value = "/{taskCode}/downstream") + @ResponseStatus(HttpStatus.OK) + @ApiException(QUERY_TASK_PROCESS_RELATION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result queryDownstreamRelation(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @PathVariable("taskCode") long taskCode) { + return returnDataList(processTaskRelationService.queryDownstreamRelation(loginUser, projectCode, taskCode)); + } +} diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/SchedulerController.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/SchedulerController.java index f3b5290d65..7df20da25e 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/SchedulerController.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/SchedulerController.java @@ -308,4 +308,47 @@ public class SchedulerController extends BaseController { Map result = schedulerService.previewSchedule(loginUser, schedule); return returnDataList(result); } + + /** + * update process definition schedule + * + * @param loginUser login user + * @param projectCode project code + * @param processDefinitionCode process definition code + * @param schedule scheduler + * @param warningType warning type + * @param warningGroupId warning group id + * @param failureStrategy failure strategy + * @param workerGroup worker group + * @param processInstancePriority process instance priority + * @return update result code + */ + @ApiOperation(value = "updateScheduleByProcessDefinitionCode", notes = "UPDATE_SCHEDULE_BY_PROCESS_DEFINITION_CODE_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "processDefinitionCode", value = "PROCESS_DEFINITION_CODE", required = true, dataType = "Long", example = "12345678"), + @ApiImplicitParam(name = "schedule", value = "SCHEDULE", dataType = "String", example = "{'startTime':'2019-06-10 00:00:00','endTime':'2019-06-13 00:00:00','crontab':'0 0 3/6 * * ? *'}"), + @ApiImplicitParam(name = "warningType", value = "WARNING_TYPE", type = "WarningType"), + @ApiImplicitParam(name = "warningGroupId", value = "WARNING_GROUP_ID", dataType = "Int", example = "100"), + @ApiImplicitParam(name = "failureStrategy", value = "FAILURE_STRATEGY", type = "FailureStrategy"), + @ApiImplicitParam(name = "workerGroupId", value = "WORKER_GROUP_ID", dataType = "Int", example = "100"), + @ApiImplicitParam(name = "processInstancePriority", value = "PROCESS_INSTANCE_PRIORITY", type = "Priority"), + @ApiImplicitParam(name = "environmentCode", value = "ENVIRONMENT_CODE", dataType = "Long"), + }) + @PutMapping("/{code}") + @ApiException(UPDATE_SCHEDULE_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result updateScheduleByProcessDefinitionCode(@ApiIgnore @RequestAttribute(value = SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @PathVariable(value = "code") long processDefinitionCode, + @RequestParam(value = "schedule") String schedule, + @RequestParam(value = "warningType", required = false, defaultValue = DEFAULT_WARNING_TYPE) WarningType warningType, + @RequestParam(value = "warningGroupId", required = false) int warningGroupId, + @RequestParam(value = "failureStrategy", required = false, defaultValue = "END") FailureStrategy failureStrategy, + @RequestParam(value = "workerGroup", required = false, defaultValue = "default") String workerGroup, + @RequestParam(value = "environmentCode", required = false, defaultValue = "-1") long environmentCode, + @RequestParam(value = "processInstancePriority", required = false) Priority processInstancePriority) { + Map result = schedulerService.updateScheduleByProcessDefinitionCode(loginUser, projectCode, processDefinitionCode, schedule, + warningType, warningGroupId, failureStrategy, processInstancePriority, workerGroup, environmentCode); + return returnDataList(result); + } } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/TaskDefinitionController.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/TaskDefinitionController.java index a8ec2f51a3..f485bff312 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/TaskDefinitionController.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/controller/TaskDefinitionController.java @@ -24,6 +24,7 @@ import static org.apache.dolphinscheduler.api.enums.Status.LOGIN_USER_QUERY_PROJ import static org.apache.dolphinscheduler.api.enums.Status.QUERY_DETAIL_OF_TASK_DEFINITION_ERROR; import static org.apache.dolphinscheduler.api.enums.Status.QUERY_TASK_DEFINITION_LIST_PAGING_ERROR; import static org.apache.dolphinscheduler.api.enums.Status.QUERY_TASK_DEFINITION_VERSIONS_ERROR; +import static org.apache.dolphinscheduler.api.enums.Status.RELEASE_TASK_DEFINITION_ERROR; import static org.apache.dolphinscheduler.api.enums.Status.SWITCH_TASK_DEFINITION_VERSION_ERROR; import static org.apache.dolphinscheduler.api.enums.Status.UPDATE_TASK_DEFINITION_ERROR; @@ -32,6 +33,7 @@ import org.apache.dolphinscheduler.api.exceptions.ApiException; import org.apache.dolphinscheduler.api.service.TaskDefinitionService; import org.apache.dolphinscheduler.api.utils.Result; import org.apache.dolphinscheduler.common.Constants; +import org.apache.dolphinscheduler.common.enums.ReleaseState; import org.apache.dolphinscheduler.common.utils.ParameterUtils; import org.apache.dolphinscheduler.dao.entity.User; @@ -310,4 +312,31 @@ public class TaskDefinitionController extends BaseController { Map result = taskDefinitionService.genTaskCodeList(genNum); return returnDataList(result); } + + /** + * release task definition + * + * @param loginUser login user + * @param projectCode project code + * @param code task definition code + * @param releaseState releaseState + * @return update result code + */ + @ApiOperation(value = "releaseTaskDefinition", notes = "RELEASE_TASK_DEFINITION_NOTES") + @ApiImplicitParams({ + @ApiImplicitParam(name = "projectCode", value = "PROCESS_DEFINITION_NAME", required = true, type = "Long"), + @ApiImplicitParam(name = "code", value = "TASK_DEFINITION_CODE", required = true, dataType = "Long", example = "123456789"), + @ApiImplicitParam(name = "releaseState", value = "RELEASE_PROCESS_DEFINITION_NOTES", required = true, dataType = "ReleaseState") + }) + @PostMapping(value = "/{code}/release") + @ResponseStatus(HttpStatus.OK) + @ApiException(RELEASE_TASK_DEFINITION_ERROR) + @AccessLogAnnotation(ignoreRequestArgs = "loginUser") + public Result releaseTaskDefinition(@ApiIgnore @RequestAttribute(value = Constants.SESSION_USER) User loginUser, + @ApiParam(name = "projectCode", value = "PROJECT_CODE", required = true) @PathVariable long projectCode, + @PathVariable(value = "code", required = true) long code, + @RequestParam(value = "releaseState", required = true, defaultValue = "OFFLINE") ReleaseState releaseState) { + Map result = taskDefinitionService.releaseTaskDefinition(loginUser, projectCode, code, releaseState); + return returnDataList(result); + } } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/enums/Status.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/enums/Status.java index 69514f7bb6..847aec130f 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/enums/Status.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/enums/Status.java @@ -280,6 +280,10 @@ public enum Status { QUERY_DETAIL_OF_TASK_DEFINITION_ERROR(50043, "query detail of task definition error", "查询任务详细信息错误"), QUERY_TASK_DEFINITION_LIST_PAGING_ERROR(50044, "query task definition list paging error", "分页查询任务定义列表错误"), TASK_DEFINITION_NAME_EXISTED(50045, "task definition name [{0}] already exists", "任务定义名称[{0}]已经存在"), + RELEASE_TASK_DEFINITION_ERROR(50046, "release task definition error", "上线任务错误"), + MOVE_PROCESS_TASK_RELATION_ERROR(50047, "move process task relation error", "移动任务到其他工作流错误"), + DELETE_TASK_PROCESS_RELATION_ERROR(50048, "delete process task relation error", "删除工作流任务关系错误"), + QUERY_TASK_PROCESS_RELATION_ERROR(50049, "query process task relation error", "查询工作流任务关系错误"), HDFS_NOT_STARTUP(60001, "hdfs not startup", "hdfs未启用"), /** diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionService.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionService.java index 2b6dc0cee6..e1e05035e2 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionService.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionService.java @@ -335,5 +335,79 @@ public interface ProcessDefinitionService { long code, int version); + /** + * create empty process definition + * + * @param loginUser login user + * @param projectCode project code + * @param name process definition name + * @param description description + * @param globalParams globalParams + * @param timeout timeout + * @param tenantCode tenantCode + * @param scheduleJson scheduleJson + * @return process definition code + */ + Map createEmptyProcessDefinition(User loginUser, + long projectCode, + String name, + String description, + String globalParams, + int timeout, + String tenantCode, + String scheduleJson, + ProcessExecutionTypeEnum executionType); + + /** + * update process definition basic info + * + * @param loginUser login user + * @param projectCode project code + * @param name process definition name + * @param code process definition code + * @param description description + * @param globalParams globalParams + * @param timeout timeout + * @param tenantCode tenantCode + * @param scheduleJson scheduleJson + * @param executionType executionType + * @return update result code + */ + Map updateProcessDefinitionBasicInfo(User loginUser, + long projectCode, + String name, + long code, + String description, + String globalParams, + int timeout, + String tenantCode, + String scheduleJson, + ProcessExecutionTypeEnum executionType); + + /** + * release process definition and schedule + * + * @param loginUser login user + * @param projectCode project code + * @param code process definition code + * @param releaseState releaseState + * @return update result code + */ + Map releaseWorkflowAndSchedule(User loginUser, + long projectCode, + long code, + ReleaseState releaseState); + + /** + * delete process definition and schedule + * + * @param loginUser login user + * @param projectCode project code + * @param code process definition code + * @return update result code + */ + Map deleteWorkflowAndSchedule(User loginUser, + long projectCode, + long code); } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessTaskRelationService.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessTaskRelationService.java new file mode 100644 index 0000000000..37099d5e21 --- /dev/null +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/ProcessTaskRelationService.java @@ -0,0 +1,126 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.dolphinscheduler.api.service; + +import org.apache.dolphinscheduler.dao.entity.User; + +import java.util.Map; + +/** + * process task relation service + */ +public interface ProcessTaskRelationService { + + /** + * create process task relation + * + * @param loginUser login user + * @param projectCode project code + * @param processDefinitionCode processDefinitionCode + * @param preTaskCode preTaskCode + * @param postTaskCode postTaskCode + * @return create result code + */ + Map createProcessTaskRelation(User loginUser, + long projectCode, + long processDefinitionCode, + long preTaskCode, + long postTaskCode); + + /** + * move task to other processDefinition + * + * @param loginUser login user info + * @param projectCode project code + * @param processDefinitionCode process definition code + * @param targetProcessDefinitionCode target process definition code + * @param taskCode the current task code (the post task code) + * @return move result code + */ + Map moveTaskProcessRelation(User loginUser, + long projectCode, + long processDefinitionCode, + long targetProcessDefinitionCode, + long taskCode); + + /** + * delete process task relation + * + * @param loginUser login user + * @param projectCode project code + * @param processDefinitionCode process definition code + * @param taskCode the post task code + * @return delete result code + */ + Map deleteTaskProcessRelation(User loginUser, + long projectCode, + long processDefinitionCode, + long taskCode); + + /** + * delete task upstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param preTaskCodes the pre task codes, sep ',' + * @param taskCode the post task code + * @return delete result code + */ + Map deleteUpstreamRelation(User loginUser, + long projectCode, + String preTaskCodes, + long taskCode); + + /** + * delete task downstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param postTaskCodes the post task codes, sep ',' + * @param taskCode the pre task code + * @return delete result code + */ + Map deleteDownstreamRelation(User loginUser, + long projectCode, + String postTaskCodes, + long taskCode); + + /** + * query task upstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param taskCode current task code (post task code) + * @return process task relation list + */ + Map queryUpstreamRelation(User loginUser, + long projectCode, + long taskCode); + + /** + * query task downstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param taskCode pre task code + * @return process task relation list + */ + Map queryDownstreamRelation(User loginUser, + long projectCode, + long taskCode); +} diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/SchedulerService.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/SchedulerService.java index bad9b3596f..b4788edcfe 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/SchedulerService.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/SchedulerService.java @@ -148,4 +148,29 @@ public interface SchedulerService { * @return the next five fire time */ Map previewSchedule(User loginUser, String schedule); + + /** + * update process definition schedule + * + * @param loginUser login user + * @param projectCode project code + * @param processDefinitionCode process definition code + * @param scheduleExpression scheduleExpression + * @param warningType warning type + * @param warningGroupId warning group id + * @param failureStrategy failure strategy + * @param workerGroup worker group + * @param processInstancePriority process instance priority + * @return update result code + */ + Map updateScheduleByProcessDefinitionCode(User loginUser, + long projectCode, + long processDefinitionCode, + String scheduleExpression, + WarningType warningType, + int warningGroupId, + FailureStrategy failureStrategy, + Priority processInstancePriority, + String workerGroup, + long environmentCode); } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/TaskDefinitionService.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/TaskDefinitionService.java index e17432929d..192bf16959 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/TaskDefinitionService.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/TaskDefinitionService.java @@ -18,6 +18,7 @@ package org.apache.dolphinscheduler.api.service; import org.apache.dolphinscheduler.api.utils.Result; +import org.apache.dolphinscheduler.common.enums.ReleaseState; import org.apache.dolphinscheduler.dao.entity.User; import java.util.Map; @@ -156,4 +157,17 @@ public interface TaskDefinitionService { */ Map genTaskCodeList(Integer genNum); + /** + * release task definition + * + * @param loginUser login user + * @param projectCode project code + * @param code task definition code + * @param releaseState releaseState + * @return update result code + */ + Map releaseTaskDefinition(User loginUser, + long projectCode, + long code, + ReleaseState releaseState); } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessDefinitionServiceImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessDefinitionServiceImpl.java index ca54eae507..47fde6ff2f 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessDefinitionServiceImpl.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessDefinitionServiceImpl.java @@ -1519,4 +1519,86 @@ public class ProcessDefinitionServiceImpl extends BaseServiceImpl implements Pro } return result; } + + /** + * create empty process definition + * + * @param loginUser login user + * @param projectCode project code + * @param name process definition name + * @param description description + * @param globalParams globalParams + * @param timeout timeout + * @param tenantCode tenantCode + * @param scheduleJson scheduleJson + * @return process definition code + */ + @Override + public Map createEmptyProcessDefinition(User loginUser, + long projectCode, + String name, + String description, + String globalParams, + int timeout, + String tenantCode, + String scheduleJson, + ProcessExecutionTypeEnum executionType) { + return null; + } + + /** + * update process definition basic info + * + * @param loginUser login user + * @param projectCode project code + * @param name process definition name + * @param code process definition code + * @param description description + * @param globalParams globalParams + * @param timeout timeout + * @param tenantCode tenantCode + * @param scheduleJson scheduleJson + * @param executionType executionType + * @return update result code + */ + @Override + public Map updateProcessDefinitionBasicInfo(User loginUser, + long projectCode, + String name, + long code, + String description, + String globalParams, + int timeout, + String tenantCode, + String scheduleJson, + ProcessExecutionTypeEnum executionType) { + return null; + } + + /** + * release process definition and schedule + * + * @param loginUser login user + * @param projectCode project code + * @param code process definition code + * @param releaseState releaseState + * @return update result code + */ + @Override + public Map releaseWorkflowAndSchedule(User loginUser, long projectCode, long code, ReleaseState releaseState) { + return null; + } + + /** + * delete process definition and schedule + * + * @param loginUser login user + * @param projectCode project code + * @param code process definition code + * @return update result code + */ + @Override + public Map deleteWorkflowAndSchedule(User loginUser, long projectCode, long code) { + return null; + } } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessTaskRelationServiceImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessTaskRelationServiceImpl.java new file mode 100644 index 0000000000..915fc21ea7 --- /dev/null +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessTaskRelationServiceImpl.java @@ -0,0 +1,151 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.dolphinscheduler.api.service.impl; + +import org.apache.dolphinscheduler.api.service.ProcessTaskRelationService; +import org.apache.dolphinscheduler.api.service.ProjectService; +import org.apache.dolphinscheduler.dao.entity.User; +import org.apache.dolphinscheduler.dao.mapper.ProcessTaskRelationMapper; +import org.apache.dolphinscheduler.dao.mapper.ProjectMapper; +import org.apache.dolphinscheduler.dao.mapper.UserMapper; + +import java.util.Map; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +/** + * process task relation service impl + */ +@Service +public class ProcessTaskRelationServiceImpl extends BaseServiceImpl implements ProcessTaskRelationService { + + private static final Logger logger = LoggerFactory.getLogger(ProcessTaskRelationServiceImpl.class); + + @Autowired + private ProjectMapper projectMapper; + + @Autowired + private ProjectService projectService; + + @Autowired + private ProcessTaskRelationMapper processTaskRelationMapper; + + @Autowired + private UserMapper userMapper; + + /** + * create process task relation + * + * @param loginUser login user + * @param projectCode project code + * @param processDefinitionCode processDefinitionCode + * @param preTaskCode preTaskCode + * @param postTaskCode postTaskCode + * @return create result code + */ + @Override + public Map createProcessTaskRelation(User loginUser, long projectCode, long processDefinitionCode, long preTaskCode, long postTaskCode) { + return null; + } + + /** + * move task to other processDefinition + * + * @param loginUser login user info + * @param projectCode project code + * @param processDefinitionCode process definition code + * @param targetProcessDefinitionCode target process definition code + * @param taskCode the current task code (the post task code) + * @return move result code + */ + @Override + public Map moveTaskProcessRelation(User loginUser, long projectCode, long processDefinitionCode, long targetProcessDefinitionCode, long taskCode) { + return null; + } + + /** + * delete process task relation + * + * @param loginUser login user + * @param projectCode project code + * @param processDefinitionCode process definition code + * @param taskCode the post task code + * @return delete result code + */ + @Override + public Map deleteTaskProcessRelation(User loginUser, long projectCode, long processDefinitionCode, long taskCode) { + return null; + } + + /** + * delete task upstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param preTaskCodes the pre task codes, sep ',' + * @param taskCode the post task code + * @return delete result code + */ + @Override + public Map deleteUpstreamRelation(User loginUser, long projectCode, String preTaskCodes, long taskCode) { + return null; + } + + /** + * delete task downstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param postTaskCodes the post task codes, sep ',' + * @param taskCode the pre task code + * @return delete result code + */ + @Override + public Map deleteDownstreamRelation(User loginUser, long projectCode, String postTaskCodes, long taskCode) { + return null; + } + + /** + * query task upstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param taskCode current task code (post task code) + * @return process task relation list + */ + @Override + public Map queryUpstreamRelation(User loginUser, long projectCode, long taskCode) { + return null; + } + + /** + * query task downstream relation + * + * @param loginUser login user + * @param projectCode project code + * @param taskCode pre task code + * @return process task relation list + */ + @Override + public Map queryDownstreamRelation(User loginUser, long projectCode, long taskCode) { + return null; + } +} diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/SchedulerServiceImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/SchedulerServiceImpl.java index bb5044ab3c..0a920aac7b 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/SchedulerServiceImpl.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/SchedulerServiceImpl.java @@ -607,4 +607,32 @@ public class SchedulerServiceImpl extends BaseServiceImpl implements SchedulerSe putMsg(result, Status.SUCCESS); return result; } + + /** + * update process definition schedule + * + * @param loginUser login user + * @param projectCode project code + * @param processDefinitionCode process definition code + * @param scheduleExpression scheduleExpression + * @param warningType warning type + * @param warningGroupId warning group id + * @param failureStrategy failure strategy + * @param workerGroup worker group + * @param processInstancePriority process instance priority + * @return update result code + */ + @Override + public Map updateScheduleByProcessDefinitionCode(User loginUser, + long projectCode, + long processDefinitionCode, + String scheduleExpression, + WarningType warningType, + int warningGroupId, + FailureStrategy failureStrategy, + Priority processInstancePriority, + String workerGroup, + long environmentCode) { + return null; + } } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/TaskDefinitionServiceImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/TaskDefinitionServiceImpl.java index e203b9b66d..938f1063ad 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/TaskDefinitionServiceImpl.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/TaskDefinitionServiceImpl.java @@ -25,6 +25,7 @@ import org.apache.dolphinscheduler.api.utils.CheckUtils; import org.apache.dolphinscheduler.api.utils.PageInfo; import org.apache.dolphinscheduler.api.utils.Result; import org.apache.dolphinscheduler.common.Constants; +import org.apache.dolphinscheduler.common.enums.ReleaseState; import org.apache.dolphinscheduler.common.utils.JSONUtils; import org.apache.dolphinscheduler.common.utils.SnowFlakeUtils; import org.apache.dolphinscheduler.common.utils.SnowFlakeUtils.SnowFlakeException; @@ -161,7 +162,7 @@ public class TaskDefinitionServiceImpl extends BaseServiceImpl implements TaskDe /** * delete task definition - * + * Only offline and no downstream dependency can be deleted * @param loginUser login user * @param projectCode project code * @param taskCode task code @@ -174,6 +175,7 @@ public class TaskDefinitionServiceImpl extends BaseServiceImpl implements TaskDe if (result.get(Constants.STATUS) != Status.SUCCESS) { return result; } + // TODO List processTaskRelationList = processTaskRelationMapper.queryByTaskCode(taskCode); if (!processTaskRelationList.isEmpty()) { Set processDefinitionCodes = processTaskRelationList @@ -427,4 +429,18 @@ public class TaskDefinitionServiceImpl extends BaseServiceImpl implements TaskDe result.put(Constants.DATA_LIST, taskCodes); return result; } + + /** + * release task definition + * + * @param loginUser login user + * @param projectCode project code + * @param code task definition code + * @param releaseState releaseState + * @return update result code + */ + @Override + public Map releaseTaskDefinition(User loginUser, long projectCode, long code, ReleaseState releaseState) { + return null; + } }