From ff2ffc97a50d16d7cec63b71fef9621ba95743c5 Mon Sep 17 00:00:00 2001 From: ruanwenjun Date: Wed, 13 May 2026 17:47:04 +0800 Subject: [PATCH] [Improvement-18249][DAO] Route ClusterMapper and K8sNamespaceMapper access through repository Dao Introduce ClusterDao and K8sNamespaceDao to encapsulate the two K8s-related mappers so the api layer depends only on the repository abstraction. The two mappers are bundled together because they share call sites in ClusterServiceImpl and K8SNamespaceServiceImpl. ClusterDao mirrors the mapper API and packages deleteByCode as boolean (returning row count > 0) to match the IDao convention. K8sNamespaceDao mirrors the mapper API; existNamespace returns primitive boolean via Boolean.TRUE.equals, and countByClusterCode encapsulates the LambdaQueryWrapper that previously leaked into ClusterServiceImpl. Tracking issue: #18249 --- .../impl/ClusterAuditOperatorImpl.java | 6 +- .../impl/K8SNamespaceAuditOperatorImpl.java | 6 +- .../dolphinscheduler/api/k8s/K8sManager.java | 8 +-- .../ResourcePermissionCheckServiceImpl.java | 10 +-- .../api/service/impl/ClusterServiceImpl.java | 36 +++++----- .../service/impl/K8SNamespaceServiceImpl.java | 32 ++++----- .../api/k8s/K8sManagerTest.java | 6 +- ...sNamespaceResourcePermissionCheckTest.java | 6 +- .../api/service/K8SNamespaceServiceTest.java | 28 ++++---- .../api/service/impl/ClusterServiceTest.java | 36 +++++----- .../dao/repository/ClusterDao.java | 37 ++++++++++ .../dao/repository/K8sNamespaceDao.java | 39 ++++++++++ .../dao/repository/impl/ClusterDaoImpl.java | 64 +++++++++++++++++ .../repository/impl/K8sNamespaceDaoImpl.java | 71 +++++++++++++++++++ 14 files changed, 296 insertions(+), 89 deletions(-) create mode 100644 dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/ClusterDao.java create mode 100644 dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/K8sNamespaceDao.java create mode 100644 dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/impl/ClusterDaoImpl.java create mode 100644 dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/impl/K8sNamespaceDaoImpl.java diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/operator/impl/ClusterAuditOperatorImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/operator/impl/ClusterAuditOperatorImpl.java index 4f1cabc043b6..401fabbf2c32 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/operator/impl/ClusterAuditOperatorImpl.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/operator/impl/ClusterAuditOperatorImpl.java @@ -19,7 +19,7 @@ import org.apache.dolphinscheduler.api.audit.operator.BaseAuditOperator; import org.apache.dolphinscheduler.dao.entity.Cluster; -import org.apache.dolphinscheduler.dao.mapper.ClusterMapper; +import org.apache.dolphinscheduler.dao.repository.ClusterDao; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @@ -28,7 +28,7 @@ public class ClusterAuditOperatorImpl extends BaseAuditOperator { @Autowired - private ClusterMapper clusterMapper; + private ClusterDao clusterDao; @Override public String getObjectNameFromIdentity(Object identity) { @@ -37,7 +37,7 @@ public String getObjectNameFromIdentity(Object identity) { return ""; } - Cluster obj = clusterMapper.queryByClusterCode(objId); + Cluster obj = clusterDao.queryByClusterCode(objId); return obj == null ? "" : obj.getName(); } } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/operator/impl/K8SNamespaceAuditOperatorImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/operator/impl/K8SNamespaceAuditOperatorImpl.java index 9f0fe6b4e524..c16bc26427b8 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/operator/impl/K8SNamespaceAuditOperatorImpl.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/audit/operator/impl/K8SNamespaceAuditOperatorImpl.java @@ -19,7 +19,7 @@ import org.apache.dolphinscheduler.api.audit.operator.BaseAuditOperator; import org.apache.dolphinscheduler.dao.entity.K8sNamespace; -import org.apache.dolphinscheduler.dao.mapper.K8sNamespaceMapper; +import org.apache.dolphinscheduler.dao.repository.K8sNamespaceDao; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @@ -28,7 +28,7 @@ public class K8SNamespaceAuditOperatorImpl extends BaseAuditOperator { @Autowired - private K8sNamespaceMapper k8sNamespaceMapper; + private K8sNamespaceDao k8sNamespaceDao; @Override public String getObjectNameFromIdentity(Object identity) { @@ -37,7 +37,7 @@ public String getObjectNameFromIdentity(Object identity) { return ""; } - K8sNamespace obj = k8sNamespaceMapper.selectById(objId); + K8sNamespace obj = k8sNamespaceDao.queryById(objId); return obj == null ? "" : obj.getNamespace(); } } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/k8s/K8sManager.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/k8s/K8sManager.java index 9c1281f84cf8..a4c459304705 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/k8s/K8sManager.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/k8s/K8sManager.java @@ -18,7 +18,7 @@ package org.apache.dolphinscheduler.api.k8s; import org.apache.dolphinscheduler.dao.entity.Cluster; -import org.apache.dolphinscheduler.dao.mapper.ClusterMapper; +import org.apache.dolphinscheduler.dao.repository.ClusterDao; import org.apache.dolphinscheduler.service.utils.ClusterConfUtils; import java.util.Hashtable; @@ -46,7 +46,7 @@ public class K8sManager { private static Map clientMap = new Hashtable<>(); @Autowired - private ClusterMapper clusterMapper; + private ClusterDao clusterDao; /** * get k8s client for api use @@ -88,7 +88,7 @@ private void deleteK8sClientInner(Long clusterCode) { if (clusterCode == null) { return; } - Cluster cluster = clusterMapper.queryByClusterCode(clusterCode); + Cluster cluster = clusterDao.queryByClusterCode(clusterCode); if (cluster == null) { return; } @@ -99,7 +99,7 @@ private void deleteK8sClientInner(Long clusterCode) { } private void createK8sClientInner(Long clusterCode) { - Cluster cluster = clusterMapper.queryByClusterCode(clusterCode); + Cluster cluster = clusterDao.queryByClusterCode(clusterCode); if (cluster == null) { return; } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/permission/ResourcePermissionCheckServiceImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/permission/ResourcePermissionCheckServiceImpl.java index d8a932aac119..b7cfd859c833 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/permission/ResourcePermissionCheckServiceImpl.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/permission/ResourcePermissionCheckServiceImpl.java @@ -37,10 +37,10 @@ import org.apache.dolphinscheduler.dao.mapper.AlertPluginInstanceMapper; import org.apache.dolphinscheduler.dao.mapper.DataSourceMapper; import org.apache.dolphinscheduler.dao.mapper.EnvironmentMapper; -import org.apache.dolphinscheduler.dao.mapper.K8sNamespaceMapper; import org.apache.dolphinscheduler.dao.mapper.QueueMapper; import org.apache.dolphinscheduler.dao.mapper.TaskGroupMapper; import org.apache.dolphinscheduler.dao.mapper.TenantMapper; +import org.apache.dolphinscheduler.dao.repository.K8sNamespaceDao; import org.apache.dolphinscheduler.dao.repository.ProjectDao; import org.apache.dolphinscheduler.dao.repository.UserDao; import org.apache.dolphinscheduler.dao.repository.WorkerGroupDao; @@ -207,10 +207,10 @@ public boolean permissionCheck(int userId, String permissionKey, Logger logger) @Component public static class K8sNamespaceResourcePermissionCheck implements ResourceAcquisitionAndPermissionCheck { - private final K8sNamespaceMapper k8sNamespaceMapper; + private final K8sNamespaceDao k8sNamespaceDao; - public K8sNamespaceResourcePermissionCheck(K8sNamespaceMapper k8sNamespaceMapper) { - this.k8sNamespaceMapper = k8sNamespaceMapper; + public K8sNamespaceResourcePermissionCheck(K8sNamespaceDao k8sNamespaceDao) { + this.k8sNamespaceDao = k8sNamespaceDao; } @Override @@ -225,7 +225,7 @@ public boolean permissionCheck(int userId, String url, Logger logger) { @Override public Set listAuthorizedResourceIds(int userId, Logger logger) { - List k8sNamespaces = k8sNamespaceMapper.queryAuthedNamespaceListByUserId(userId); + List k8sNamespaces = k8sNamespaceDao.queryAuthedNamespaceListByUserId(userId); return k8sNamespaces.stream().map(K8sNamespace::getId).collect(Collectors.toSet()); } } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ClusterServiceImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ClusterServiceImpl.java index ab65a7cb5342..b764729d9ac7 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ClusterServiceImpl.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ClusterServiceImpl.java @@ -27,10 +27,9 @@ import org.apache.dolphinscheduler.common.utils.CodeGenerateUtils; import org.apache.dolphinscheduler.common.utils.DateUtils; import org.apache.dolphinscheduler.dao.entity.Cluster; -import org.apache.dolphinscheduler.dao.entity.K8sNamespace; import org.apache.dolphinscheduler.dao.entity.User; -import org.apache.dolphinscheduler.dao.mapper.ClusterMapper; -import org.apache.dolphinscheduler.dao.mapper.K8sNamespaceMapper; +import org.apache.dolphinscheduler.dao.repository.ClusterDao; +import org.apache.dolphinscheduler.dao.repository.K8sNamespaceDao; import org.apache.dolphinscheduler.service.utils.ClusterConfUtils; import org.apache.commons.collections4.CollectionUtils; @@ -48,7 +47,6 @@ import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; -import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; @@ -60,13 +58,13 @@ public class ClusterServiceImpl extends BaseServiceImpl implements ClusterService { @Autowired - private ClusterMapper clusterMapper; + private ClusterDao clusterDao; @Autowired private K8sManager k8sManager; @Autowired - private K8sNamespaceMapper k8sNamespaceMapper; + private K8sNamespaceDao k8sNamespaceDao; /** * create cluster @@ -85,7 +83,7 @@ public Long createCluster(User loginUser, String name, String config, String des checkParams(name, config); - Cluster clusterExistByName = clusterMapper.queryByClusterName(name); + Cluster clusterExistByName = clusterDao.queryByClusterName(name); if (clusterExistByName != null) { throw new ServiceException(Status.CLUSTER_NAME_EXISTS, name); } @@ -99,7 +97,7 @@ public Long createCluster(User loginUser, String name, String config, String des cluster.setUpdateTime(new Date()); cluster.setCode(CodeGenerateUtils.genCode()); - if (clusterMapper.insert(cluster) > 0) { + if (clusterDao.insert(cluster) > 0) { return cluster.getCode(); } throw new ServiceException(Status.CREATE_CLUSTER_ERROR); @@ -118,7 +116,7 @@ public PageInfo queryClusterListPaging(Integer pageNo, Integer pageS Page page = new Page<>(pageNo, pageSize); - IPage clusterIPage = clusterMapper.queryClusterListPaging(page, searchVal); + IPage clusterIPage = clusterDao.queryClusterListPaging(page, searchVal); PageInfo pageInfo = new PageInfo<>(pageNo, pageSize); pageInfo.setTotal((int) clusterIPage.getTotal()); @@ -142,7 +140,7 @@ public PageInfo queryClusterListPaging(Integer pageNo, Integer pageS */ @Override public List queryAllClusterList() { - List clusterList = clusterMapper.queryAllClusterList(); + List clusterList = clusterDao.queryAllClusterList(); if (CollectionUtils.isEmpty(clusterList)) { return Collections.emptyList(); } @@ -164,7 +162,7 @@ public List queryAllClusterList() { @Override public ClusterDto queryClusterByCode(Long code) { - Cluster cluster = clusterMapper.queryByClusterCode(code); + Cluster cluster = clusterDao.queryByClusterCode(code); if (cluster == null) { throw new ServiceException(Status.QUERY_CLUSTER_BY_CODE_ERROR, code); @@ -182,7 +180,7 @@ public ClusterDto queryClusterByCode(Long code) { @Override public ClusterDto queryClusterByName(String name) { - Cluster cluster = clusterMapper.queryByClusterName(name); + Cluster cluster = clusterDao.queryByClusterName(name); if (cluster == null) { throw new ServiceException(Status.QUERY_CLUSTER_BY_NAME_ERROR, name); } @@ -203,15 +201,13 @@ public void deleteClusterByCode(User loginUser, Long code) { throw new ServiceException(Status.USER_NO_OPERATION_PERM); } - Long relatedNamespaceNumber = k8sNamespaceMapper - .selectCount(new QueryWrapper().lambda().eq(K8sNamespace::getClusterCode, code)); + long relatedNamespaceNumber = k8sNamespaceDao.countByClusterCode(code); if (relatedNamespaceNumber > 0) { throw new ServiceException(Status.DELETE_CLUSTER_RELATED_NAMESPACE_EXISTS); } - int delete = clusterMapper.deleteByCode(code); - if (delete > 0) { + if (clusterDao.deleteByCode(code)) { return; } throw new ServiceException(Status.DELETE_CLUSTER_ERROR); @@ -242,12 +238,12 @@ public Cluster updateClusterByCode(User loginUser, checkParams(name, config); - Cluster clusterExistByName = clusterMapper.queryByClusterName(name); + Cluster clusterExistByName = clusterDao.queryByClusterName(name); if (clusterExistByName != null && !clusterExistByName.getCode().equals(code)) { throw new ServiceException(Status.CLUSTER_NAME_EXISTS, name); } - Cluster clusterExist = clusterMapper.queryByClusterCode(code); + Cluster clusterExist = clusterDao.queryByClusterCode(code); if (clusterExist == null) { throw new ServiceException(Status.CLUSTER_NOT_EXISTS, name); } @@ -267,7 +263,7 @@ public Cluster updateClusterByCode(User loginUser, clusterExist.setName(name); clusterExist.setDescription(desc); clusterExist.setUpdateTime(DateUtils.getCurrentDate()); - clusterMapper.updateById(clusterExist); + clusterDao.updateById(clusterExist); return clusterExist; } @@ -284,7 +280,7 @@ public void verifyCluster(String clusterName) { throw new ServiceException(Status.CLUSTER_NAME_IS_NULL); } - Cluster cluster = clusterMapper.queryByClusterName(clusterName); + Cluster cluster = clusterDao.queryByClusterName(clusterName); if (cluster != null) { throw new ServiceException(Status.CLUSTER_NAME_EXISTS); } diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/K8SNamespaceServiceImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/K8SNamespaceServiceImpl.java index 95cfb2450490..8c31dc2d8b58 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/K8SNamespaceServiceImpl.java +++ b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/K8SNamespaceServiceImpl.java @@ -28,8 +28,8 @@ import org.apache.dolphinscheduler.dao.entity.Cluster; import org.apache.dolphinscheduler.dao.entity.K8sNamespace; import org.apache.dolphinscheduler.dao.entity.User; -import org.apache.dolphinscheduler.dao.mapper.ClusterMapper; -import org.apache.dolphinscheduler.dao.mapper.K8sNamespaceMapper; +import org.apache.dolphinscheduler.dao.repository.ClusterDao; +import org.apache.dolphinscheduler.dao.repository.K8sNamespaceDao; import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.StringUtils; @@ -59,13 +59,13 @@ public class K8SNamespaceServiceImpl extends BaseServiceImpl implements K8sNamespaceService { @Autowired - private K8sNamespaceMapper k8sNamespaceMapper; + private K8sNamespaceDao k8sNamespaceDao; @Autowired private K8sClientService k8sClientService; @Autowired - private ClusterMapper clusterMapper; + private ClusterDao clusterDao; /** * query namespace list paging @@ -87,7 +87,7 @@ public Result queryListPaging(User loginUser, String searchVal, Integer pageNo, Page page = new Page<>(pageNo, pageSize); - IPage k8sNamespaceList = k8sNamespaceMapper.queryK8sNamespacePaging(page, searchVal); + IPage k8sNamespaceList = k8sNamespaceDao.queryK8sNamespacePaging(page, searchVal); Integer count = (int) k8sNamespaceList.getTotal(); PageInfo pageInfo = new PageInfo<>(pageNo, pageSize); @@ -127,7 +127,7 @@ public K8sNamespace registerK8sNamespace(User loginUser, String namespace, Long throw new ServiceException(Status.K8S_NAMESPACE_EXIST, namespace, clusterCode); } - Cluster cluster = clusterMapper.queryByClusterCode(clusterCode); + Cluster cluster = clusterDao.queryByClusterCode(clusterCode); if (cluster == null) { log.error("Cluster does not exist, clusterCode:{}", clusterCode); throw new ServiceException(Status.CLUSTER_NOT_EXISTS, namespace, clusterCode); @@ -155,7 +155,7 @@ public K8sNamespace registerK8sNamespace(User loginUser, String namespace, Long } } - k8sNamespaceMapper.insert(k8sNamespaceObj); + k8sNamespaceDao.insert(k8sNamespaceObj); log.info("K8s namespace create complete, namespace:{}.", k8sNamespaceObj.getNamespace()); return k8sNamespaceObj; } @@ -204,13 +204,13 @@ public void deleteNamespaceById(User loginUser, int id) { throw new ServiceException(Status.USER_NO_OPERATION_PERM); } - K8sNamespace k8sNamespaceObj = k8sNamespaceMapper.selectById(id); + K8sNamespace k8sNamespaceObj = k8sNamespaceDao.queryById(id); if (k8sNamespaceObj == null) { log.error("K8s namespace does not exist, namespaceId:{}.", id); throw new ServiceException(Status.K8S_NAMESPACE_NOT_EXIST, id); } - k8sNamespaceMapper.deleteById(id); + k8sNamespaceDao.deleteById(id); log.info("K8s namespace delete complete, namespace:{}.", k8sNamespaceObj.getNamespace()); } @@ -221,7 +221,7 @@ public void deleteNamespaceById(User loginUser, int id) { * @return true if the k8s and namespace not exists, otherwise return false */ private boolean checkNamespaceExistInDb(String namespace, Long clusterCode) { - return k8sNamespaceMapper.existNamespace(namespace, clusterCode) == Boolean.TRUE; + return k8sNamespaceDao.existNamespace(namespace, clusterCode); } /** @@ -237,12 +237,12 @@ public List queryUnauthorizedNamespace(User loginUser, Integer use throw new ServiceException(Status.USER_NO_OPERATION_PERM); } // query all namespace list, this auth does not like project - List namespaceList = k8sNamespaceMapper.selectList(null); + List namespaceList = k8sNamespaceDao.queryAll(); if (namespaceList == null || namespaceList.isEmpty()) { return Collections.emptyList(); } Set namespaceSet = new HashSet<>(namespaceList); - List authedProjectList = k8sNamespaceMapper.queryAuthedNamespaceListByUserId(userId); + List authedProjectList = k8sNamespaceDao.queryAuthedNamespaceListByUserId(userId); return getUnauthorizedNamespaces(namespaceSet, authedProjectList); } @@ -258,7 +258,7 @@ public List queryAuthorizedNamespace(User loginUser, Integer userI if (loginUser.getId() != userId && isNotAdmin(loginUser)) { throw new ServiceException(Status.USER_NO_OPERATION_PERM); } - return k8sNamespaceMapper.queryAuthedNamespaceListByUserId(userId); + return k8sNamespaceDao.queryAuthedNamespaceListByUserId(userId); } /** @@ -271,9 +271,9 @@ public List queryAuthorizedNamespace(User loginUser, Integer userI public List queryNamespaceAvailable(User loginUser) { List k8sNamespaces; if (isAdmin(loginUser)) { - k8sNamespaces = k8sNamespaceMapper.selectList(null); + k8sNamespaces = k8sNamespaceDao.queryAll(); } else { - k8sNamespaces = k8sNamespaceMapper.queryAuthedNamespaceListByUserId(loginUser.getId()); + k8sNamespaces = k8sNamespaceDao.queryAuthedNamespaceListByUserId(loginUser.getId()); } setClusterName(k8sNamespaces); return k8sNamespaces; @@ -285,7 +285,7 @@ public List queryNamespaceAvailable(User loginUser) { */ private void setClusterName(List k8sNamespaces) { if (CollectionUtils.isNotEmpty(k8sNamespaces)) { - List clusters = clusterMapper.queryAllClusterList(); + List clusters = clusterDao.queryAllClusterList(); if (CollectionUtils.isNotEmpty(clusters)) { Map codeNameMap = clusters.stream() .collect(Collectors.toMap(Cluster::getCode, Cluster::getName, (a, b) -> a)); diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/k8s/K8sManagerTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/k8s/K8sManagerTest.java index e08e8cc797df..738451d7ee85 100644 --- a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/k8s/K8sManagerTest.java +++ b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/k8s/K8sManagerTest.java @@ -18,7 +18,7 @@ package org.apache.dolphinscheduler.api.k8s; import org.apache.dolphinscheduler.dao.entity.Cluster; -import org.apache.dolphinscheduler.dao.mapper.ClusterMapper; +import org.apache.dolphinscheduler.dao.repository.ClusterDao; import java.util.ArrayList; import java.util.List; @@ -45,7 +45,7 @@ public class K8sManagerTest { private K8sManager k8sManager; @Mock - private ClusterMapper clusterMapper; + private ClusterDao clusterDao; @BeforeEach public void setUp() throws Exception { @@ -57,7 +57,7 @@ public void tearDown() throws Exception { @Test public void getK8sClient() { - Mockito.when(clusterMapper.selectList(Mockito.any())).thenReturn(getClusterList()); + Mockito.when(clusterDao.queryAll()).thenReturn(getClusterList()); KubernetesClient result = k8sManager.getK8sClient(1L); Assertions.assertNull(result); diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/permission/K8sNamespaceResourcePermissionCheckTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/permission/K8sNamespaceResourcePermissionCheckTest.java index 674444ef28fd..5943dd19b098 100644 --- a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/permission/K8sNamespaceResourcePermissionCheckTest.java +++ b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/permission/K8sNamespaceResourcePermissionCheckTest.java @@ -21,7 +21,7 @@ import org.apache.dolphinscheduler.common.enums.UserType; import org.apache.dolphinscheduler.dao.entity.K8sNamespace; import org.apache.dolphinscheduler.dao.entity.User; -import org.apache.dolphinscheduler.dao.mapper.K8sNamespaceMapper; +import org.apache.dolphinscheduler.dao.repository.K8sNamespaceDao; import java.util.Arrays; import java.util.Collections; @@ -47,7 +47,7 @@ public class K8sNamespaceResourcePermissionCheckTest { private ResourcePermissionCheckServiceImpl.K8sNamespaceResourcePermissionCheck k8sNamespaceResourcePermissionCheck; @Mock - private K8sNamespaceMapper k8sNamespaceMapper; + private K8sNamespaceDao k8sNamespaceDao; @Test public void testPermissionCheck() { @@ -69,7 +69,7 @@ public void testListAuthorizedResourceIds() { ids.add(k8sNamespace.getId()); List k8sNamespaces = Arrays.asList(k8sNamespace); - Mockito.when(k8sNamespaceMapper.queryAuthedNamespaceListByUserId(user.getId())).thenReturn(k8sNamespaces); + Mockito.when(k8sNamespaceDao.queryAuthedNamespaceListByUserId(user.getId())).thenReturn(k8sNamespaces); Assertions.assertEquals(ids, k8sNamespaceResourcePermissionCheck.listAuthorizedResourceIds(user.getId(), logger)); diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/K8SNamespaceServiceTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/K8SNamespaceServiceTest.java index 371f9ba4d6c2..15fdce62b1d7 100644 --- a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/K8SNamespaceServiceTest.java +++ b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/K8SNamespaceServiceTest.java @@ -28,8 +28,8 @@ import org.apache.dolphinscheduler.dao.entity.Cluster; import org.apache.dolphinscheduler.dao.entity.K8sNamespace; import org.apache.dolphinscheduler.dao.entity.User; -import org.apache.dolphinscheduler.dao.mapper.ClusterMapper; -import org.apache.dolphinscheduler.dao.mapper.K8sNamespaceMapper; +import org.apache.dolphinscheduler.dao.repository.ClusterDao; +import org.apache.dolphinscheduler.dao.repository.K8sNamespaceDao; import org.apache.commons.collections4.CollectionUtils; @@ -62,10 +62,10 @@ public class K8SNamespaceServiceTest { private K8SNamespaceServiceImpl k8sNamespaceService; @Mock - private K8sNamespaceMapper k8sNamespaceMapper; + private K8sNamespaceDao k8sNamespaceDao; @Mock - private ClusterMapper clusterMapper; + private ClusterDao clusterDao; @Mock private K8sClientService k8sClientService; @@ -78,7 +78,7 @@ public void queryListPaging() { IPage page = new Page<>(1, 10); page.setTotal(1L); page.setRecords(getNamespaceList()); - Mockito.when(k8sNamespaceMapper.queryK8sNamespacePaging(Mockito.any(Page.class), Mockito.eq(namespace))) + Mockito.when(k8sNamespaceDao.queryK8sNamespacePaging(Mockito.any(Page.class), Mockito.eq(namespace))) .thenReturn(page); Result result = k8sNamespaceService.queryListPaging(getLoginUser(), namespace, 1, 10); logger.info(result.toString()); @@ -95,7 +95,7 @@ public void createK8sNamespace() { assertThrowsServiceException(Status.REQUEST_PARAMS_NOT_VALID_ERROR, () -> k8sNamespaceService.registerK8sNamespace(getLoginUser(), namespace, null)); // correct - Mockito.when(clusterMapper.queryByClusterCode(Mockito.anyLong())).thenReturn(getCluster()); + Mockito.when(clusterDao.queryByClusterCode(Mockito.anyLong())).thenReturn(getCluster()); K8sNamespace created = k8sNamespaceService.registerK8sNamespace(getLoginUser(), namespace, clusterCode); Assertions.assertNotNull(created); Assertions.assertEquals(namespace, created.getNamespace()); @@ -105,7 +105,7 @@ public void createK8sNamespace() { @Test public void verifyNamespaceK8s() { - Mockito.when(k8sNamespaceMapper.existNamespace(namespace, clusterCode)).thenReturn(true); + Mockito.when(k8sNamespaceDao.existNamespace(namespace, clusterCode)).thenReturn(true); // namespace null Result result = k8sNamespaceService.verifyNamespaceK8s(null, clusterCode); @@ -130,15 +130,15 @@ public void verifyNamespaceK8s() { @Test public void deleteNamespaceById() { - Mockito.when(k8sNamespaceMapper.deleteById(Mockito.any())).thenReturn(1); - Mockito.when(k8sNamespaceMapper.selectById(1)).thenReturn(getNamespace()); + Mockito.when(k8sNamespaceDao.deleteById(Mockito.any())).thenReturn(true); + Mockito.when(k8sNamespaceDao.queryById(1)).thenReturn(getNamespace()); Assertions.assertDoesNotThrow(() -> k8sNamespaceService.deleteNamespaceById(getLoginUser(), 1)); } @Test public void testQueryAuthorizedNamespace() { - Mockito.when(k8sNamespaceMapper.queryAuthedNamespaceListByUserId(2)).thenReturn(getNamespaceList()); + Mockito.when(k8sNamespaceDao.queryAuthedNamespaceListByUserId(2)).thenReturn(getNamespaceList()); User loginUser = getLoginUser(); @@ -156,8 +156,8 @@ public void testQueryAuthorizedNamespace() { @Test public void testQueryUnAuthorizedNamespace() { - Mockito.when(k8sNamespaceMapper.queryAuthedNamespaceListByUserId(2)).thenReturn(new ArrayList<>()); - Mockito.when(k8sNamespaceMapper.selectList(Mockito.any())).thenReturn(getNamespaceList()); + Mockito.when(k8sNamespaceDao.queryAuthedNamespaceListByUserId(2)).thenReturn(new ArrayList<>()); + Mockito.when(k8sNamespaceDao.queryAll()).thenReturn(getNamespaceList()); // test admin user User loginUser = new User(); @@ -185,8 +185,8 @@ public void testQueryNamespaceAvailable() { cluster.setName("test"); clusters.add(cluster); - Mockito.when(k8sNamespaceMapper.selectList(Mockito.any())).thenReturn(k8sNamespaces); - Mockito.when(clusterMapper.queryAllClusterList()).thenReturn(clusters); + Mockito.when(k8sNamespaceDao.queryAll()).thenReturn(k8sNamespaces); + Mockito.when(clusterDao.queryAllClusterList()).thenReturn(clusters); List result = k8sNamespaceService.queryNamespaceAvailable(getLoginUser()); Assertions.assertEquals(result.get(0).getClusterName(), cluster.getName()); } diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/impl/ClusterServiceTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/impl/ClusterServiceTest.java index 068b2ed15ea0..68c0dc8b0ed9 100644 --- a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/impl/ClusterServiceTest.java +++ b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/impl/ClusterServiceTest.java @@ -29,8 +29,8 @@ import org.apache.dolphinscheduler.common.enums.UserType; import org.apache.dolphinscheduler.dao.entity.Cluster; import org.apache.dolphinscheduler.dao.entity.User; -import org.apache.dolphinscheduler.dao.mapper.ClusterMapper; -import org.apache.dolphinscheduler.dao.mapper.K8sNamespaceMapper; +import org.apache.dolphinscheduler.dao.repository.ClusterDao; +import org.apache.dolphinscheduler.dao.repository.K8sNamespaceDao; import org.apache.commons.collections4.CollectionUtils; @@ -62,13 +62,13 @@ public class ClusterServiceTest { private ClusterServiceImpl clusterService; @Mock - private ClusterMapper clusterMapper; + private ClusterDao clusterDao; @Mock private K8sManager k8sManager; @Mock - private K8sNamespaceMapper k8sNamespaceMapper; + private K8sNamespaceDao k8sNamespaceDao; public static final String testUserName = "clusterServerTest"; @@ -98,11 +98,11 @@ public void testCreateCluster() { assertThrowsServiceException(Status.CLUSTER_NAME_IS_NULL, () -> clusterService.createCluster(loginUser, "", getConfig(), getDesc())); - when(clusterMapper.queryByClusterName(clusterName)).thenReturn(getCluster()); + when(clusterDao.queryByClusterName(clusterName)).thenReturn(getCluster()); assertThrowsServiceException(Status.CLUSTER_NAME_EXISTS, () -> clusterService.createCluster(loginUser, clusterName, getConfig(), getDesc())); - when(clusterMapper.insert(Mockito.any(Cluster.class))).thenReturn(1); + when(clusterDao.insert(Mockito.any(Cluster.class))).thenReturn(1); Assertions.assertDoesNotThrow( () -> clusterService.createCluster(loginUser, "testName", "testConfig", "testDesc")); } @@ -128,12 +128,12 @@ public void testUpdateClusterByCode() { assertThrowsServiceException(Status.CLUSTER_NOT_EXISTS, () -> clusterService.updateClusterByCode(adminUser, 2L, clusterName, getConfig(), getDesc())); - when(clusterMapper.queryByClusterName(clusterName)).thenReturn(getCluster()); + when(clusterDao.queryByClusterName(clusterName)).thenReturn(getCluster()); assertThrowsServiceException(Status.CLUSTER_NAME_EXISTS, () -> clusterService.updateClusterByCode(adminUser, 2L, clusterName, getConfig(), getDesc())); - when(clusterMapper.updateById(Mockito.any(Cluster.class))).thenReturn(1); - when(clusterMapper.queryByClusterCode(1L)).thenReturn(getCluster()); + when(clusterDao.updateById(Mockito.any(Cluster.class))).thenReturn(true); + when(clusterDao.queryByClusterCode(1L)).thenReturn(getCluster()); Cluster cluster = clusterService.updateClusterByCode(adminUser, 1L, "testName", getConfig(), "test"); assertNotNull(cluster); assertNotNull(cluster.getUpdateTime()); @@ -141,7 +141,7 @@ public void testUpdateClusterByCode() { @Test public void testQueryAllClusterList() { - when(clusterMapper.queryAllClusterList()).thenReturn(Lists.newArrayList(getCluster())); + when(clusterDao.queryAllClusterList()).thenReturn(Lists.newArrayList(getCluster())); List clusterDtos = clusterService.queryAllClusterList(); Assertions.assertEquals(clusterDtos.size(), 1); } @@ -151,7 +151,7 @@ public void testQueryClusterListPaging() { IPage page = new Page<>(1, 10); page.setRecords(getList()); page.setTotal(1L); - when(clusterMapper.queryClusterListPaging(Mockito.any(Page.class), Mockito.eq(clusterName))).thenReturn(page); + when(clusterDao.queryClusterListPaging(Mockito.any(Page.class), Mockito.eq(clusterName))).thenReturn(page); PageInfo clusterDtoPageInfo = clusterService.queryClusterListPaging(1, 10, clusterName); Assertions.assertTrue(CollectionUtils.isNotEmpty(clusterDtoPageInfo.getTotalList())); @@ -159,21 +159,21 @@ public void testQueryClusterListPaging() { @Test public void testQueryClusterByName() { - when(clusterMapper.queryByClusterName(clusterName)).thenReturn(null); + when(clusterDao.queryByClusterName(clusterName)).thenReturn(null); assertThrowsServiceException(Status.QUERY_CLUSTER_BY_NAME_ERROR, () -> clusterService.queryClusterByName(clusterName)); - when(clusterMapper.queryByClusterName(clusterName)).thenReturn(getCluster()); + when(clusterDao.queryByClusterName(clusterName)).thenReturn(getCluster()); ClusterDto clusterDto = clusterService.queryClusterByName(clusterName); assertNotNull(clusterDto); } @Test public void testQueryClusterByCode() { - when(clusterMapper.queryByClusterCode(1L)).thenReturn(null); + when(clusterDao.queryByClusterCode(1L)).thenReturn(null); assertThrowsServiceException(Status.QUERY_CLUSTER_BY_CODE_ERROR, () -> clusterService.queryClusterByCode(1L)); - when(clusterMapper.queryByClusterCode(1L)).thenReturn(getCluster()); + when(clusterDao.queryByClusterCode(1L)).thenReturn(getCluster()); ClusterDto clusterDto = clusterService.queryClusterByCode(1L); assertNotNull(clusterDto); } @@ -186,10 +186,10 @@ public void testDeleteClusterByCode() { }); final User adminUser = getAdminUser(); - when(clusterMapper.deleteByCode(1L)).thenReturn(1); + when(clusterDao.deleteByCode(1L)).thenReturn(true); assertDoesNotThrow(() -> clusterService.deleteClusterByCode(adminUser, 1L)); - when(k8sNamespaceMapper.selectCount(Mockito.any())).thenReturn(1L); + when(k8sNamespaceDao.countByClusterCode(Mockito.anyLong())).thenReturn(1L); assertThrowsServiceException(Status.DELETE_CLUSTER_RELATED_NAMESPACE_EXISTS, () -> clusterService.deleteClusterByCode(adminUser, 1L)); } @@ -198,7 +198,7 @@ public void testDeleteClusterByCode() { public void testVerifyCluster() { assertThrowsServiceException(Status.CLUSTER_NAME_IS_NULL, () -> clusterService.verifyCluster("")); - when(clusterMapper.queryByClusterName(clusterName)).thenReturn(getCluster()); + when(clusterDao.queryByClusterName(clusterName)).thenReturn(getCluster()); assertThrowsServiceException(Status.CLUSTER_NAME_EXISTS, () -> clusterService.verifyCluster(clusterName)); } diff --git a/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/ClusterDao.java b/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/ClusterDao.java new file mode 100644 index 000000000000..e8b3086ecd0c --- /dev/null +++ b/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/ClusterDao.java @@ -0,0 +1,37 @@ +/* + * 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.dao.repository; + +import org.apache.dolphinscheduler.dao.entity.Cluster; + +import java.util.List; + +import com.baomidou.mybatisplus.core.metadata.IPage; + +public interface ClusterDao extends IDao { + + Cluster queryByClusterName(String name); + + Cluster queryByClusterCode(Long clusterCode); + + List queryAllClusterList(); + + IPage queryClusterListPaging(IPage page, String searchName); + + boolean deleteByCode(Long code); +} diff --git a/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/K8sNamespaceDao.java b/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/K8sNamespaceDao.java new file mode 100644 index 000000000000..cec428f3751a --- /dev/null +++ b/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/K8sNamespaceDao.java @@ -0,0 +1,39 @@ +/* + * 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.dao.repository; + +import org.apache.dolphinscheduler.dao.entity.K8sNamespace; + +import java.util.List; + +import com.baomidou.mybatisplus.core.metadata.IPage; + +public interface K8sNamespaceDao extends IDao { + + IPage queryK8sNamespacePaging(IPage page, String searchVal); + + boolean existNamespace(String namespace, Long clusterCode); + + List queryNamespaceExceptUserId(int userId); + + List queryAuthedNamespaceListByUserId(Integer userId); + + K8sNamespace queryByNamespaceCode(Long namespaceCode); + + long countByClusterCode(Long clusterCode); +} diff --git a/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/impl/ClusterDaoImpl.java b/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/impl/ClusterDaoImpl.java new file mode 100644 index 000000000000..78219717f382 --- /dev/null +++ b/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/impl/ClusterDaoImpl.java @@ -0,0 +1,64 @@ +/* + * 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.dao.repository.impl; + +import org.apache.dolphinscheduler.dao.entity.Cluster; +import org.apache.dolphinscheduler.dao.mapper.ClusterMapper; +import org.apache.dolphinscheduler.dao.repository.BaseDao; +import org.apache.dolphinscheduler.dao.repository.ClusterDao; + +import java.util.List; + +import lombok.NonNull; + +import org.springframework.stereotype.Repository; + +import com.baomidou.mybatisplus.core.metadata.IPage; + +@Repository +public class ClusterDaoImpl extends BaseDao implements ClusterDao { + + public ClusterDaoImpl(@NonNull ClusterMapper clusterMapper) { + super(clusterMapper); + } + + @Override + public Cluster queryByClusterName(String name) { + return mybatisMapper.queryByClusterName(name); + } + + @Override + public Cluster queryByClusterCode(Long clusterCode) { + return mybatisMapper.queryByClusterCode(clusterCode); + } + + @Override + public List queryAllClusterList() { + return mybatisMapper.queryAllClusterList(); + } + + @Override + public IPage queryClusterListPaging(IPage page, String searchName) { + return mybatisMapper.queryClusterListPaging(page, searchName); + } + + @Override + public boolean deleteByCode(Long code) { + return mybatisMapper.deleteByCode(code) > 0; + } +} diff --git a/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/impl/K8sNamespaceDaoImpl.java b/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/impl/K8sNamespaceDaoImpl.java new file mode 100644 index 000000000000..6b9c43efaaa1 --- /dev/null +++ b/dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/repository/impl/K8sNamespaceDaoImpl.java @@ -0,0 +1,71 @@ +/* + * 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.dao.repository.impl; + +import org.apache.dolphinscheduler.dao.entity.K8sNamespace; +import org.apache.dolphinscheduler.dao.mapper.K8sNamespaceMapper; +import org.apache.dolphinscheduler.dao.repository.BaseDao; +import org.apache.dolphinscheduler.dao.repository.K8sNamespaceDao; + +import java.util.List; + +import lombok.NonNull; + +import org.springframework.stereotype.Repository; + +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; + +@Repository +public class K8sNamespaceDaoImpl extends BaseDao implements K8sNamespaceDao { + + public K8sNamespaceDaoImpl(@NonNull K8sNamespaceMapper k8sNamespaceMapper) { + super(k8sNamespaceMapper); + } + + @Override + public IPage queryK8sNamespacePaging(IPage page, String searchVal) { + return mybatisMapper.queryK8sNamespacePaging(page, searchVal); + } + + @Override + public boolean existNamespace(String namespace, Long clusterCode) { + return Boolean.TRUE.equals(mybatisMapper.existNamespace(namespace, clusterCode)); + } + + @Override + public List queryNamespaceExceptUserId(int userId) { + return mybatisMapper.queryNamespaceExceptUserId(userId); + } + + @Override + public List queryAuthedNamespaceListByUserId(Integer userId) { + return mybatisMapper.queryAuthedNamespaceListByUserId(userId); + } + + @Override + public K8sNamespace queryByNamespaceCode(Long namespaceCode) { + return mybatisMapper.queryByNamespaceCode(namespaceCode); + } + + @Override + public long countByClusterCode(Long clusterCode) { + return mybatisMapper.selectCount( + new QueryWrapper().lambda().eq(K8sNamespace::getClusterCode, clusterCode)); + } +}