diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceAcquireLockAspect.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceAcquireLockAspect.java index 629b1ce0118..fa6c68a7027 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceAcquireLockAspect.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceAcquireLockAspect.java @@ -88,7 +88,7 @@ public void requireLockAdvice(String appId, String clusterName, String namespace public void requireLockAdvice(long itemId, String operator) { Item item = itemService.findOne(itemId); if (item == null){ - throw new BadRequestException("item not exist."); + throw BadRequestException.itemNotExists(itemId); } acquireLock(item.getNamespaceId(), operator); } @@ -117,7 +117,7 @@ void acquireLock(long namespaceId, String currentUser) { private void acquireLock(Namespace namespace, String currentUser) { if (namespace == null) { - throw new BadRequestException("namespace not exist."); + throw BadRequestException.namespaceNotExists(); } long namespaceId = namespace.getId(); diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceUnlockAspect.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceUnlockAspect.java index df2ab519c43..2695bbc402b 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceUnlockAspect.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceUnlockAspect.java @@ -101,7 +101,7 @@ public void requireLockAdvice(String appId, String clusterName, String namespace public void requireLockAdvice(long itemId, String operator) { Item item = itemService.findOne(itemId); if (item == null) { - throw new BadRequestException("item not exist."); + throw BadRequestException.itemNotExists(itemId); } tryUnlock(namespaceService.findOne(item.getNamespaceId())); } diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/AppController.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/AppController.java index 541be0e364d..fc2c20e2719 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/AppController.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/AppController.java @@ -54,7 +54,7 @@ public AppDTO create(@Valid @RequestBody AppDTO dto) { App entity = BeanUtils.transform(App.class, dto); App managedEntity = appService.findOne(entity.getAppId()); if (managedEntity != null) { - throw new BadRequestException("app already exist."); + throw BadRequestException.appAlreadyExists(entity.getAppId()); } entity = adminService.createNewApp(entity); @@ -66,7 +66,7 @@ public AppDTO create(@Valid @RequestBody AppDTO dto) { public void delete(@PathVariable("appId") String appId, @RequestParam String operator) { App entity = appService.findOne(appId); if (entity == null) { - throw new NotFoundException("app not found for appId " + appId); + throw NotFoundException.appNotFound(appId); } adminService.deleteApp(entity, operator); } @@ -96,7 +96,7 @@ public List find(@RequestParam(value = "name", required = false) String public AppDTO get(@PathVariable("appId") String appId) { App app = appService.findOne(appId); if (app == null) { - throw new NotFoundException("app not found for appId " + appId); + throw NotFoundException.appNotFound(appId); } return BeanUtils.transform(AppDTO.class, app); } diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/AppNamespaceController.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/AppNamespaceController.java index 1117bcda5b8..15c1eeecea2 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/AppNamespaceController.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/AppNamespaceController.java @@ -69,7 +69,7 @@ public AppNamespaceDTO create(@RequestBody AppNamespaceDTO appNamespace, entity = managedEntity; } else { - throw new BadRequestException("app namespaces already exist."); + throw BadRequestException.appNamespaceAlreadyExists(entity.getAppId(), entity.getName()); } return BeanUtils.transform(AppNamespaceDTO.class, entity); @@ -80,7 +80,7 @@ public void delete(@PathVariable("appId") String appId, @PathVariable("namespace @RequestParam String operator) { AppNamespace entity = appNamespaceService.findOne(appId, namespaceName); if (entity == null) { - throw new BadRequestException("app namespace not found for appId: " + appId + " namespace: " + namespaceName); + throw BadRequestException.appNamespaceNotExists(appId, namespaceName); } appNamespaceService.deleteAppNamespace(entity, operator); } diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ClusterController.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ClusterController.java index ea931819073..7a58bd18fea 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ClusterController.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ClusterController.java @@ -50,7 +50,7 @@ public ClusterDTO create(@PathVariable("appId") String appId, Cluster entity = BeanUtils.transform(Cluster.class, dto); Cluster managedEntity = clusterService.findOne(appId, entity.getName()); if (managedEntity != null) { - throw new BadRequestException("cluster already exist."); + throw BadRequestException.clusterAlreadyExists(entity.getName()); } if (autoCreatePrivateNamespace) { @@ -69,7 +69,7 @@ public void delete(@PathVariable("appId") String appId, Cluster entity = clusterService.findOne(appId, clusterName); if (entity == null) { - throw new NotFoundException("cluster not found for clusterName " + clusterName); + throw NotFoundException.clusterNotFound(appId, clusterName); } if(ConfigConsts.CLUSTER_NAME_DEFAULT.equals(entity.getName())){ @@ -90,7 +90,7 @@ public ClusterDTO get(@PathVariable("appId") String appId, @PathVariable("clusterName") String clusterName) { Cluster cluster = clusterService.findOne(appId, clusterName); if (cluster == null) { - throw new NotFoundException("cluster not found for name " + clusterName); + throw NotFoundException.clusterNotFound(appId, clusterName); } return BeanUtils.transform(ClusterDTO.class, cluster); } diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/InstanceConfigController.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/InstanceConfigController.java index d047f37cced..c087a5035c7 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/InstanceConfigController.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/InstanceConfigController.java @@ -70,7 +70,7 @@ public PageDTO getByRelease(@RequestParam("releaseId") long release Pageable pageable) { Release release = releaseService.findOne(releaseId); if (release == null) { - throw new NotFoundException("release not found for %s", releaseId); + throw NotFoundException.releaseNotFound(releaseId); } Page instanceConfigsPage = instanceService.findActiveInstanceConfigsByReleaseKey (release.getReleaseKey(), pageable); @@ -123,7 +123,7 @@ public List getByReleasesNotIn(@RequestParam("appId") String appId, List releases = releaseService.findByReleaseIds(releaseIdSet); if (CollectionUtils.isEmpty(releases)) { - throw new NotFoundException("releases not found for %s", releaseIds); + throw NotFoundException.releaseNotFound(releaseIds); } Set releaseKeys = releases.stream().map(Release::getReleaseKey).collect(Collectors diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ItemController.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ItemController.java index d4eb8a54557..124ed556895 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ItemController.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ItemController.java @@ -75,7 +75,7 @@ public ItemDTO create(@PathVariable("appId") String appId, Item managedEntity = itemService.findOne(appId, clusterName, namespaceName, entity.getKey()); if (managedEntity != null) { - throw new BadRequestException("item already exists"); + throw BadRequestException.itemAlreadyExists(entity.getKey()); } entity = itemService.save(entity); dto = BeanUtils.transform(ItemDTO.class, entity); @@ -122,13 +122,13 @@ public ItemDTO update(@PathVariable("appId") String appId, @RequestBody ItemDTO itemDTO) { Item managedEntity = itemService.findOne(itemId); if (managedEntity == null) { - throw new NotFoundException("item not found for itemId " + itemId); + throw NotFoundException.itemNotFound(appId, clusterName, namespaceName, itemId); } Namespace namespace = namespaceService.findOne(appId, clusterName, namespaceName); // In case someone constructs an attack scenario if (namespace == null || namespace.getId() != managedEntity.getNamespaceId()) { - throw new BadRequestException("Invalid request, item and namespace do not match!"); + throw BadRequestException.namespaceNotMatch(); } Item entity = BeanUtils.transform(Item.class, itemDTO); @@ -159,7 +159,7 @@ public ItemDTO update(@PathVariable("appId") String appId, public void delete(@PathVariable("itemId") long itemId, @RequestParam String operator) { Item entity = itemService.findOne(itemId); if (entity == null) { - throw new NotFoundException("item not found for itemId " + itemId); + throw NotFoundException.itemNotFound(itemId); } itemService.delete(entity.getId(), operator); @@ -205,7 +205,7 @@ public List findDeletedItems(@PathVariable("appId") String appId, public ItemDTO get(@PathVariable("itemId") long itemId) { Item item = itemService.findOne(itemId); if (item == null) { - throw new NotFoundException("item not found for itemId " + itemId); + throw NotFoundException.itemNotFound(itemId); } return BeanUtils.transform(ItemDTO.class, item); } @@ -216,8 +216,7 @@ public ItemDTO get(@PathVariable("appId") String appId, @PathVariable("namespaceName") String namespaceName, @PathVariable("key") String key) { Item item = itemService.findOne(appId, clusterName, namespaceName, key); if (item == null) { - throw new NotFoundException("item not found for %s %s %s %s", appId, clusterName, - namespaceName, key); + throw NotFoundException.itemNotFound(appId, clusterName, namespaceName, key); } return BeanUtils.transform(ItemDTO.class, item); } diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceBranchController.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceBranchController.java index 6a1886bc70f..e90881b275b 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceBranchController.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceBranchController.java @@ -157,9 +157,7 @@ private void checkBranch(String appId, String clusterName, String namespaceName, private void checkNamespace(String appId, String clusterName, String namespaceName) { Namespace parentNamespace = namespaceService.findOne(appId, clusterName, namespaceName); if (parentNamespace == null) { - throw new BadRequestException( - "Namespace not exist. AppId = %s, ClusterName = %s, NamespaceName = %s", appId, - clusterName, namespaceName); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } } diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceController.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceController.java index ccfa066703b..3c7da29b146 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceController.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceController.java @@ -54,7 +54,7 @@ public NamespaceDTO create(@PathVariable("appId") String appId, Namespace entity = BeanUtils.transform(Namespace.class, dto); Namespace managedEntity = namespaceService.findOne(appId, clusterName, entity.getNamespaceName()); if (managedEntity != null) { - throw new BadRequestException("namespace already exist."); + throw BadRequestException.namespaceAlreadyExists(entity.getNamespaceName()); } entity = namespaceService.save(entity); @@ -68,8 +68,7 @@ public void delete(@PathVariable("appId") String appId, @PathVariable("namespaceName") String namespaceName, @RequestParam String operator) { Namespace entity = namespaceService.findOne(appId, clusterName, namespaceName); if (entity == null) { - throw new NotFoundException("namespace not found for %s %s %s", appId, clusterName, - namespaceName); + throw NotFoundException.namespaceNotFound(appId, clusterName, namespaceName); } namespaceService.deleteNamespace(entity, operator); @@ -86,7 +85,7 @@ public List find(@PathVariable("appId") String appId, public NamespaceDTO get(@PathVariable("namespaceId") Long namespaceId) { Namespace namespace = namespaceService.findOne(namespaceId); if (namespace == null) { - throw new NotFoundException("namespace not found for %s", namespaceId); + throw NotFoundException.itemNotFound(namespaceId); } return BeanUtils.transform(NamespaceDTO.class, namespace); } @@ -109,8 +108,7 @@ public NamespaceDTO get(@PathVariable("appId") String appId, @PathVariable("namespaceName") String namespaceName) { Namespace namespace = namespaceService.findOne(appId, clusterName, namespaceName); if (namespace == null) { - throw new NotFoundException("namespace not found for %s %s %s", appId, clusterName, - namespaceName); + throw NotFoundException.namespaceNotFound(appId, clusterName, namespaceName); } return BeanUtils.transform(NamespaceDTO.class, namespace); } diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceLockController.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceLockController.java index 2b5fd666db0..a5e5709fe84 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceLockController.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/NamespaceLockController.java @@ -49,7 +49,7 @@ public NamespaceLockDTO getNamespaceLockOwner(@PathVariable String appId, @PathV @PathVariable String namespaceName) { Namespace namespace = namespaceService.findOne(appId, clusterName, namespaceName); if (namespace == null) { - throw new BadRequestException("namespace not exist."); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } if (bizConfig.isNamespaceLockSwitchOff()) { diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ReleaseController.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ReleaseController.java index a71c2d9e734..d408cca15a8 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ReleaseController.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/controller/ReleaseController.java @@ -72,7 +72,7 @@ public ReleaseController( public ReleaseDTO get(@PathVariable("releaseId") long releaseId) { Release release = releaseService.findOne(releaseId); if (release == null) { - throw new NotFoundException("release not found for %s", releaseId); + throw NotFoundException.releaseNotFound(releaseId); } return BeanUtils.transform(ReleaseDTO.class, release); } @@ -125,8 +125,7 @@ public ReleaseDTO publish(@PathVariable("appId") String appId, @RequestParam(name = "isEmergencyPublish", defaultValue = "false") boolean isEmergencyPublish) { Namespace namespace = namespaceService.findOne(appId, clusterName, namespaceName); if (namespace == null) { - throw new NotFoundException("Could not find namespace for %s %s %s", appId, clusterName, - namespaceName); + throw NotFoundException.namespaceNotFound(appId, clusterName, namespaceName); } Release release = releaseService.publish(namespace, releaseName, releaseComment, operator, isEmergencyPublish); @@ -162,8 +161,7 @@ public ReleaseDTO updateAndPublish(@PathVariable("appId") String appId, @RequestBody ItemChangeSets changeSets) { Namespace namespace = namespaceService.findOne(appId, clusterName, namespaceName); if (namespace == null) { - throw new NotFoundException("Could not find namespace for %s %s %s", appId, clusterName, - namespaceName); + throw NotFoundException.namespaceNotFound(appId, clusterName, namespaceName); } Release release = releaseService.mergeBranchChangeSetsAndRelease(namespace, branchName, releaseName, @@ -214,11 +212,10 @@ public ReleaseDTO publish(@PathVariable("appId") String appId, @RequestParam(name = "grayDelKeys") Set grayDelKeys){ Namespace namespace = namespaceService.findOne(appId, clusterName, namespaceName); if (namespace == null) { - throw new NotFoundException("Could not find namespace for %s %s %s", appId, clusterName, - namespaceName); + throw NotFoundException.namespaceNotFound(appId, clusterName, namespaceName); } - Release release = releaseService.grayDeletionPublish(namespace, releaseName, releaseComment, + Release release = releaseService.grayDeletionPublish(namespace, releaseName, releaseComment, operator, isEmergencyPublish, grayDelKeys); //send release message diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AccessKeyService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AccessKeyService.java index 56de82c6670..2306e0de3b0 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AccessKeyService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AccessKeyService.java @@ -71,7 +71,7 @@ public AccessKey update(String appId, AccessKey entity) { AccessKey accessKey = accessKeyRepository.findOneByAppIdAndId(appId, id); if (accessKey == null) { - throw new BadRequestException("AccessKey not exist"); + throw BadRequestException.accessKeyNotExists(); } accessKey.setEnabled(entity.isEnabled()); @@ -86,7 +86,7 @@ public AccessKey update(String appId, AccessKey entity) { public void delete(String appId, long id, String operator) { AccessKey accessKey = accessKeyRepository.findOneByAppIdAndId(appId, id); if (accessKey == null) { - throw new BadRequestException("AccessKey not exist"); + throw BadRequestException.accessKeyNotExists(); } if (accessKey.isEnabled()) { diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AppService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AppService.java index 774b147e9ef..14fa621cb5b 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AppService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AppService.java @@ -92,7 +92,7 @@ public void update(App app) { App managedApp = appRepository.findByAppId(appId); if (managedApp == null) { - throw new BadRequestException("App not exists. AppId = %s", appId); + throw BadRequestException.appNotExists(appId); } managedApp.setName(app.getName()); diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ClusterService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ClusterService.java index 1296776d074..b1744724674 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ClusterService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ClusterService.java @@ -107,7 +107,7 @@ public Cluster saveWithoutInstanceOfAppNamespaces(Cluster entity) { public void delete(long id, String operator) { Cluster cluster = clusterRepository.findById(id).orElse(null); if (cluster == null) { - throw new BadRequestException("cluster not exist"); + throw BadRequestException.clusterNotExists(""); } //delete linked namespaces @@ -151,7 +151,7 @@ public void createDefaultCluster(String appId, String createBy) { public List findChildClusters(String appId, String parentClusterName) { Cluster parentCluster = findOne(appId, parentClusterName); if (parentCluster == null) { - throw new BadRequestException("parent cluster not exist"); + throw BadRequestException.clusterNotExists(parentClusterName); } return clusterRepository.findByParentClusterId(parentCluster.getId()); diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ItemService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ItemService.java index ea436bc455b..a6bba2afc0b 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ItemService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ItemService.java @@ -256,8 +256,7 @@ private Namespace findNamespaceByAppIdAndClusterNameAndNamespaceName(String appI String namespaceName) { Namespace namespace = namespaceService.findOne(appId, clusterName, namespaceName); if (namespace == null) { - throw new NotFoundException("namespace not found for appId:%s clusterName:%s namespaceName:%s", - appId, clusterName, namespaceName); + throw NotFoundException.namespaceNotFound(appId, clusterName, namespaceName); } return namespace; } diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ItemSetService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ItemSetService.java index f9cdf58548b..1734dbef346 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ItemSetService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ItemSetService.java @@ -61,7 +61,7 @@ public ItemChangeSets updateSet(String appId, String clusterName, Namespace namespace = namespaceService.findOne(appId, clusterName, namespaceName); if (namespace == null) { - throw new NotFoundException("Namespace %s not found", namespaceName); + throw NotFoundException.namespaceNotFound(appId, clusterName, namespaceName); } String operator = changeSet.getDataChangeLastModifiedBy(); @@ -96,7 +96,7 @@ private void doDeleteItems(List toDeleteItems, Namespace namespace, Str for (ItemDTO item : toDeleteItems) { Item deletedItem = itemService.delete(item.getId(), operator); if (deletedItem.getNamespaceId() != namespace.getId()) { - throw new BadRequestException("Invalid request, item and namespace do not match!"); + throw BadRequestException.namespaceNotMatch(); } configChangeContentBuilder.deleteItem(deletedItem); @@ -111,10 +111,10 @@ private void doUpdateItems(List toUpdateItems, Namespace namespace, Str Item managedItem = itemService.findOne(entity.getId()); if (managedItem == null) { - throw new NotFoundException("item not found.(key=%s)", entity.getKey()); + throw NotFoundException.itemNotFound(entity.getKey()); } if (managedItem.getNamespaceId() != namespace.getId()) { - throw new BadRequestException("Invalid request, item and namespace do not match!"); + throw BadRequestException.namespaceNotMatch(); } Item beforeUpdateItem = BeanUtils.transform(Item.class, managedItem); @@ -135,7 +135,7 @@ private void doCreateItems(List toCreateItems, Namespace namespace, Str for (ItemDTO item : toCreateItems) { if (item.getNamespaceId() != namespace.getId()) { - throw new BadRequestException("Invalid request, item and namespace do not match!"); + throw BadRequestException.namespaceNotMatch(); } Item entity = BeanUtils.transform(Item.class, item); diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/NamespaceBranchService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/NamespaceBranchService.java index e44c13d35e5..03acbb2a5a2 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/NamespaceBranchService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/NamespaceBranchService.java @@ -64,12 +64,12 @@ public NamespaceBranchService( public Namespace createBranch(String appId, String parentClusterName, String namespaceName, String operator){ Namespace childNamespace = findBranch(appId, parentClusterName, namespaceName); if (childNamespace != null){ - throw new BadRequestException("namespace already has branch"); + throw BadRequestException.namespaceNotExists(appId, parentClusterName, namespaceName); } Cluster parentCluster = clusterService.findOne(appId, parentClusterName); if (parentCluster == null || parentCluster.getParentClusterId() != 0) { - throw new BadRequestException("cluster not exist or illegal cluster"); + throw BadRequestException.clusterNotExists(parentClusterName); } //create child cluster diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/NamespaceService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/NamespaceService.java index be7646edfb3..2c098566ae6 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/NamespaceService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/NamespaceService.java @@ -124,7 +124,7 @@ public Page findByItem(String itemKey, Pageable pageable) { public Namespace findPublicNamespaceForAssociatedNamespace(String clusterName, String namespaceName) { AppNamespace appNamespace = appNamespaceService.findPublicNamespaceByName(namespaceName); if (appNamespace == null) { - throw new BadRequestException("namespace not exist"); + throw BadRequestException.namespaceNotExists("", clusterName, namespaceName); } String appId = appNamespace.getAppId(); @@ -392,7 +392,7 @@ public void instanceOfAppNamespaces(String appId, String clusterName, String cre public Map namespacePublishInfo(String appId) { List clusters = clusterService.findParentClusters(appId); if (CollectionUtils.isEmpty(clusters)) { - throw new BadRequestException("app not exist"); + throw BadRequestException.appNotExists(appId); } Map clusterHasNotPublishedItems = Maps.newHashMap(); diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ReleaseService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ReleaseService.java index 29085df58be..b62afb20f1e 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ReleaseService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ReleaseService.java @@ -460,7 +460,7 @@ private Release createRelease(Namespace namespace, String name, String comment, public Release rollback(long releaseId, String operator) { Release release = findOne(releaseId); if (release == null) { - throw new NotFoundException("release not found"); + throw NotFoundException.releaseNotFound(releaseId); } if (release.isAbandoned()) { throw new BadRequestException("release is not active"); @@ -503,8 +503,12 @@ public Release rollbackTo(long releaseId, long toReleaseId, String operator) { Release release = findOne(releaseId); Release toRelease = findOne(toReleaseId); - if (release == null || toRelease == null) { - throw new NotFoundException("release not found"); + + if (release == null) { + throw NotFoundException.releaseNotFound(releaseId); + } + if (toRelease == null) { + throw NotFoundException.releaseNotFound(toReleaseId); } if (release.isAbandoned() || toRelease.isAbandoned()) { throw new BadRequestException("release is not active"); diff --git a/apollo-common/src/main/java/com/ctrip/framework/apollo/common/exception/BadRequestException.java b/apollo-common/src/main/java/com/ctrip/framework/apollo/common/exception/BadRequestException.java index 553a6ba148e..2a3715a72e4 100644 --- a/apollo-common/src/main/java/com/ctrip/framework/apollo/common/exception/BadRequestException.java +++ b/apollo-common/src/main/java/com/ctrip/framework/apollo/common/exception/BadRequestException.java @@ -22,11 +22,97 @@ public class BadRequestException extends AbstractApolloHttpException { /** - * @see AbstractApolloHttpException#AbstractApolloHttpException(String, Object...) + * @see AbstractApolloHttpException#AbstractApolloHttpException(String, Object...) */ public BadRequestException(String msgtpl, Object... args) { super(msgtpl, args); setHttpStatus(HttpStatus.BAD_REQUEST); } + public static BadRequestException itemAlreadyExists(String itemKey) { + return new BadRequestException("item already exists for itemKey:%s", itemKey); + } + + public static BadRequestException itemNotExists(long itemId) { + return new BadRequestException("item not exists for itemId:%s", itemId); + } + + public static BadRequestException namespaceNotExists() { + return new BadRequestException("namespace not exist."); + } + + public static BadRequestException namespaceNotExists(String appId, String clusterName, + String namespaceName) { + return new BadRequestException( + "namespace not exist for appId:%s clusterName:%s namespaceName:%s", appId, clusterName, + namespaceName); + } + + public static BadRequestException namespaceAlreadyExists(String namespaceName) { + return new BadRequestException("namespace already exists for namespaceName:%s", namespaceName); + } + + public static BadRequestException appNamespaceNotExists(String appId, String namespaceName) { + return new BadRequestException("appNamespace not exist for appId:%s namespaceName:%s", appId, namespaceName); + } + + public static BadRequestException appNamespaceAlreadyExists(String appId, String namespaceName) { + return new BadRequestException("appNamespace already exists for appId:%s namespaceName:%s", appId, namespaceName); + } + + public static BadRequestException invalidNamespaceFormat(String format) { + return new BadRequestException("invalid namespace format:%s", format); + } + + public static BadRequestException invalidNotificationsFormat(String format) { + return new BadRequestException("invalid notifications format:%s", format); + } + + public static BadRequestException invalidClusterNameFormat(String format) { + return new BadRequestException("invalid clusterName format:%s", format); + } + + public static BadRequestException invalidRoleTypeFormat(String format) { + return new BadRequestException("invalid roleType format:%s", format); + } + + public static BadRequestException invalidEnvFormat(String format) { + return new BadRequestException("invalid env format:%s", format); + } + + public static BadRequestException namespaceNotMatch() { + return new BadRequestException("invalid request, item and namespace do not match!"); + } + + public static BadRequestException appNotExists(String appId) { + return new BadRequestException("app not exists for appId:%s", appId); + } + + public static BadRequestException appAlreadyExists(String appId) { + return new BadRequestException("app already exists for appId:%s", appId); + } + + public static BadRequestException clusterNotExists(String clusterName) { + return new BadRequestException("cluster not exists for clusterName:%s", clusterName); + } + + public static BadRequestException clusterAlreadyExists(String clusterName) { + return new BadRequestException("cluster already exists for clusterName:%s", clusterName); + } + + public static BadRequestException userNotExists(String userName) { + return new BadRequestException("user not exists for userName:%s", userName); + } + + public static BadRequestException userAlreadyExists(String userName) { + return new BadRequestException("user already exists for userName:%s", userName); + } + + public static BadRequestException userAlreadyAuthorized(String userName) { + return new BadRequestException("%s already authorized", userName); + } + + public static BadRequestException accessKeyNotExists() { + return new BadRequestException("accessKey not exist."); + } } diff --git a/apollo-common/src/main/java/com/ctrip/framework/apollo/common/exception/NotFoundException.java b/apollo-common/src/main/java/com/ctrip/framework/apollo/common/exception/NotFoundException.java index c1568b25f54..8ba0cf43901 100644 --- a/apollo-common/src/main/java/com/ctrip/framework/apollo/common/exception/NotFoundException.java +++ b/apollo-common/src/main/java/com/ctrip/framework/apollo/common/exception/NotFoundException.java @@ -27,4 +27,41 @@ public NotFoundException(String msgTpl, Object... args) { super(msgTpl, args); setHttpStatus(HttpStatus.NOT_FOUND); } + + public static NotFoundException itemNotFound(long itemId) { + return new NotFoundException("item not found for itemId:%s",itemId); + } + + public static NotFoundException itemNotFound(String itemKey) { + return new NotFoundException("item not found for itemKey:%s",itemKey); + } + + public static NotFoundException itemNotFound(String appId, String clusterName, String namespaceName, String itemKey) { + return new NotFoundException("item not found for appId:%s clusterName:%s namespaceName:%s itemKey:%s", appId, clusterName, namespaceName, itemKey); + } + + public static NotFoundException itemNotFound(String appId, String clusterName, String namespaceName, long itemId) { + return new NotFoundException("item not found for appId:%s clusterName:%s namespaceName:%s itemId:%s", appId, clusterName, namespaceName, itemId); + } + + public static NotFoundException namespaceNotFound(String appId, String clusterName, String namespaceName) { + return new NotFoundException("namespace not found for appId:%s clusterName:%s namespaceName:%s", appId, clusterName, namespaceName); + } + + public static NotFoundException namespaceNotFound(long namespaceId) { + return new NotFoundException("namespace not found for namespaceId:%s", namespaceId); + } + + public static NotFoundException releaseNotFound(Object releaseId) { + return new NotFoundException("release not found for releaseId:%s", releaseId); + } + + public static NotFoundException clusterNotFound(String appId, String clusterName) { + return new NotFoundException("cluster not found for appId:%s clusterName:%s", appId, clusterName); + } + + public static NotFoundException appNotFound(String appId) { + return new NotFoundException("app not found for appId:%s", appId); + } + } diff --git a/apollo-common/src/test/java/com/ctrip/framework/apollo/common/exception/BadRequestExceptionTest.java b/apollo-common/src/test/java/com/ctrip/framework/apollo/common/exception/BadRequestExceptionTest.java new file mode 100644 index 00000000000..b9a48c82758 --- /dev/null +++ b/apollo-common/src/test/java/com/ctrip/framework/apollo/common/exception/BadRequestExceptionTest.java @@ -0,0 +1,156 @@ +/* + * Copyright 2023 Apollo Authors + * + * Licensed 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 com.ctrip.framework.apollo.common.exception; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +/** + * @author kl (http://kailing.pub) + * @since 2023/3/22 + */ +public class BadRequestExceptionTest { + + private static final String appId = "app-1001"; + private static final String clusterName = "test"; + private static final String namespaceName = "application"; + + @Test + public void testItemAlreadyExists() { + BadRequestException itemAlreadyExists = BadRequestException.itemAlreadyExists("itemKey"); + assertEquals("item already exists for itemKey:itemKey", itemAlreadyExists.getMessage()); + } + + @Test + public void testItemNotExists() { + BadRequestException itemNotExists = BadRequestException.itemNotExists(1001); + assertEquals("item not exists for itemId:1001", itemNotExists.getMessage()); + } + + @Test + public void testNamespaceNotExists() { + BadRequestException namespaceNotExists = BadRequestException.namespaceNotExists(); + assertEquals("namespace not exist.", namespaceNotExists.getMessage()); + + BadRequestException namespaceNotExists2 = BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); + assertEquals("namespace not exist for appId:app-1001 clusterName:test namespaceName:application", namespaceNotExists2.getMessage()); + } + + @Test + public void testNamespaceAlreadyExists() { + BadRequestException namespaceAlreadyExists = BadRequestException.namespaceAlreadyExists(namespaceName); + assertEquals("namespace already exists for namespaceName:application", namespaceAlreadyExists.getMessage()); + } + + @Test + public void testAppNamespaceNotExists() { + BadRequestException appNamespaceNotExists = BadRequestException.appNamespaceNotExists(appId, namespaceName); + assertEquals("appNamespace not exist for appId:app-1001 namespaceName:application", appNamespaceNotExists.getMessage()); + } + + @Test + public void testAppNamespaceAlreadyExists() { + BadRequestException appNamespaceAlreadyExists = BadRequestException.appNamespaceAlreadyExists(appId, namespaceName); + assertEquals("appNamespace already exists for appId:app-1001 namespaceName:application", appNamespaceAlreadyExists.getMessage()); + } + + @Test + public void testInvalidNamespaceFormat() { + BadRequestException invalidNamespaceFormat = BadRequestException.invalidNamespaceFormat("format"); + assertEquals("invalid namespace format:format", invalidNamespaceFormat.getMessage()); + } + + @Test + public void testInvalidNotificationsFormat() { + BadRequestException invalidNotificationsFormat = BadRequestException.invalidNotificationsFormat("format"); + assertEquals("invalid notifications format:format", invalidNotificationsFormat.getMessage()); + } + + @Test + public void testInvalidClusterNameFormat() { + BadRequestException invalidClusterNameFormat = BadRequestException.invalidClusterNameFormat("format"); + assertEquals("invalid clusterName format:format", invalidClusterNameFormat.getMessage()); + } + + @Test + public void testInvalidRoleTypeFormat() { + BadRequestException invalidRoleTypeFormat = BadRequestException.invalidRoleTypeFormat("format"); + assertEquals("invalid roleType format:format", invalidRoleTypeFormat.getMessage()); + } + + @Test + public void testInvalidEnvFormat() { + BadRequestException invalidEnvFormat = BadRequestException.invalidEnvFormat("format"); + assertEquals("invalid env format:format", invalidEnvFormat.getMessage()); + } + + @Test + public void testNamespaceNotMatch(){ + BadRequestException namespaceNotMatch = BadRequestException.namespaceNotMatch(); + assertEquals("invalid request, item and namespace do not match!", namespaceNotMatch.getMessage()); + } + + @Test + public void testAppNotExists(){ + BadRequestException appNotExists = BadRequestException.appNotExists(appId); + assertEquals("app not exists for appId:app-1001", appNotExists.getMessage()); + } + + @Test + public void testAppAlreadyExists(){ + BadRequestException appAlreadyExists = BadRequestException.appAlreadyExists(appId); + assertEquals("app already exists for appId:app-1001", appAlreadyExists.getMessage()); + } + + @Test + public void testClusterNotExists(){ + BadRequestException clusterNotExists = BadRequestException.clusterNotExists(clusterName); + assertEquals("cluster not exists for clusterName:test", clusterNotExists.getMessage()); + } + + @Test + public void testClusterAlreadyExists(){ + BadRequestException clusterAlreadyExists = BadRequestException.clusterAlreadyExists(clusterName); + assertEquals("cluster already exists for clusterName:test", clusterAlreadyExists.getMessage()); + } + + @Test + public void testUserNotExists(){ + BadRequestException userNotExists = BadRequestException.userNotExists("user"); + assertEquals("user not exists for userName:user", userNotExists.getMessage()); + } + + @Test + public void testUserAlreadyExists(){ + BadRequestException userAlreadyExists = BadRequestException.userAlreadyExists("user"); + assertEquals("user already exists for userName:user", userAlreadyExists.getMessage()); + } + + @Test + public void testUserAlreadyAuthorized(){ + BadRequestException userAlreadyAuthorized = BadRequestException.userAlreadyAuthorized("user"); + assertEquals("user already authorized", userAlreadyAuthorized.getMessage()); + } + + @Test + public void testAccessKeyNotExists(){ + BadRequestException accessKeyNotExists = BadRequestException.accessKeyNotExists(); + assertEquals("accessKey not exist.", accessKeyNotExists.getMessage()); + } + +} diff --git a/apollo-common/src/test/java/com/ctrip/framework/apollo/common/exception/NotFoundExceptionTest.java b/apollo-common/src/test/java/com/ctrip/framework/apollo/common/exception/NotFoundExceptionTest.java index 7d72fe0c414..51827805ba8 100644 --- a/apollo-common/src/test/java/com/ctrip/framework/apollo/common/exception/NotFoundExceptionTest.java +++ b/apollo-common/src/test/java/com/ctrip/framework/apollo/common/exception/NotFoundExceptionTest.java @@ -21,11 +21,12 @@ public class NotFoundExceptionTest { + private static final String appId = "app-1001"; + private static final String clusterName = "test"; + private static final String namespaceName = "application"; + @Test public void testConstructor() { - String appId = "app-1001"; - String clusterName = "test"; - String namespaceName = "application"; String key = "test.key"; NotFoundException e1, e2; e1 = new NotFoundException("item not found for %s %s %s %s", appId, @@ -35,4 +36,46 @@ public void testConstructor() { Assert.assertEquals(e1.getMessage(), e2.getMessage()); } + @Test + public void testAppNotFoundException() { + NotFoundException exception = NotFoundException.appNotFound(appId); + Assert.assertEquals(exception.getMessage(), "app not found for appId:app-1001"); + } + + @Test + public void testClusterNotFoundException() { + NotFoundException exception = NotFoundException.clusterNotFound(appId, clusterName); + Assert.assertEquals(exception.getMessage(), "cluster not found for appId:app-1001 clusterName:test"); + } + + @Test + public void testNamespaceNotFoundException() { + NotFoundException exception = NotFoundException.namespaceNotFound(appId, clusterName, namespaceName); + Assert.assertEquals(exception.getMessage(), "namespace not found for appId:app-1001 clusterName:test namespaceName:application"); + + exception = NotFoundException.namespaceNotFound(66); + Assert.assertEquals(exception.getMessage(), "namespace not found for namespaceId:66"); + } + + @Test + public void testReleaseNotFoundException() { + NotFoundException exception = NotFoundException.releaseNotFound(66); + Assert.assertEquals(exception.getMessage(), "release not found for releaseId:66"); + } + + @Test + public void testItemNotFoundException(){ + NotFoundException exception = NotFoundException.itemNotFound(66); + Assert.assertEquals(exception.getMessage(), "item not found for itemId:66"); + + exception = NotFoundException.itemNotFound("test.key"); + Assert.assertEquals(exception.getMessage(), "item not found for itemKey:test.key"); + + exception = NotFoundException.itemNotFound(appId, clusterName, namespaceName, "test.key"); + Assert.assertEquals(exception.getMessage(), "item not found for appId:app-1001 clusterName:test namespaceName:application itemKey:test.key"); + + exception = NotFoundException.itemNotFound(appId, clusterName, namespaceName, 66); + Assert.assertEquals(exception.getMessage(), "item not found for appId:app-1001 clusterName:test namespaceName:application itemId:66"); + } + } \ No newline at end of file diff --git a/apollo-configservice/src/main/java/com/ctrip/framework/apollo/configservice/controller/NotificationControllerV2.java b/apollo-configservice/src/main/java/com/ctrip/framework/apollo/configservice/controller/NotificationControllerV2.java index 95b9a5baadf..e2163b4a703 100644 --- a/apollo-configservice/src/main/java/com/ctrip/framework/apollo/configservice/controller/NotificationControllerV2.java +++ b/apollo-configservice/src/main/java/com/ctrip/framework/apollo/configservice/controller/NotificationControllerV2.java @@ -122,19 +122,19 @@ public DeferredResult>> pollNotifi } if (CollectionUtils.isEmpty(notifications)) { - throw new BadRequestException("Invalid format of notifications: " + notificationsAsString); + throw BadRequestException.invalidNotificationsFormat(notificationsAsString); } - + Map filteredNotifications = filterNotifications(appId, notifications); if (CollectionUtils.isEmpty(filteredNotifications)) { - throw new BadRequestException("Invalid format of notifications: " + notificationsAsString); + throw BadRequestException.invalidNotificationsFormat(notificationsAsString); } - + DeferredResultWrapper deferredResultWrapper = new DeferredResultWrapper(bizConfig.longPollingTimeoutInMilli()); Set namespaces = Sets.newHashSetWithExpectedSize(filteredNotifications.size()); Map clientSideNotifications = Maps.newHashMapWithExpectedSize(filteredNotifications.size()); - + for (Map.Entry notificationEntry : filteredNotifications.entrySet()) { String normalizedNamespace = notificationEntry.getKey(); ApolloConfigNotification notification = notificationEntry.getValue(); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/service/ConsumerService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/service/ConsumerService.java index 76675ee61f2..922f7430fb3 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/service/ConsumerService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/service/ConsumerService.java @@ -104,7 +104,7 @@ public Consumer createConsumer(Consumer consumer) { String ownerName = consumer.getOwnerName(); UserInfo owner = userService.findByUserId(ownerName); if (owner == null) { - throw new BadRequestException("User does not exist. UserId = %s", ownerName); + throw BadRequestException.userNotExists(ownerName); } consumer.setOwnerEmail(owner.getEmail()); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ClusterController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ClusterController.java index f6c59ae3135..235d8927f2e 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ClusterController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ClusterController.java @@ -71,12 +71,11 @@ public OpenClusterDTO createCluster(@PathVariable String appId, @PathVariable St "name and dataChangeCreatedBy should not be null or empty"); if (!InputValidator.isValidClusterNamespace(clusterName)) { - throw new BadRequestException( - String.format("Invalid ClusterName format: %s", InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE)); + throw BadRequestException.invalidClusterNameFormat(InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE); } if (userService.findByUserId(operator) == null) { - throw new BadRequestException("User " + operator + " doesn't exist!"); + throw BadRequestException.userNotExists(operator); } return this.clusterOpenApiService.createCluster(env, cluster); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ItemController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ItemController.java index fd9e74a0ac7..c9afb429e4b 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ItemController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ItemController.java @@ -18,6 +18,7 @@ import com.ctrip.framework.apollo.common.dto.ItemDTO; import com.ctrip.framework.apollo.common.exception.BadRequestException; +import com.ctrip.framework.apollo.common.exception.NotFoundException; import com.ctrip.framework.apollo.common.utils.RequestPrecondition; import com.ctrip.framework.apollo.core.utils.StringUtils; import com.ctrip.framework.apollo.openapi.api.ItemOpenApiService; @@ -88,7 +89,7 @@ public OpenItemDTO createItem(@PathVariable String appId, @PathVariable String e "key and dataChangeCreatedBy should not be null or empty"); if (userService.findByUserId(item.getDataChangeCreatedBy()) == null) { - throw new BadRequestException("User " + item.getDataChangeCreatedBy() + " doesn't exist!"); + throw BadRequestException.userNotExists(item.getDataChangeCreatedBy()); } if (!StringUtils.isEmpty(item.getComment()) && item.getComment().length() > ITEM_COMMENT_MAX_LENGTH) { @@ -114,7 +115,7 @@ public void updateItem(@PathVariable String appId, @PathVariable String env, RequestPrecondition.checkArguments(item.getKey().equals(key), "Key in path and payload is not consistent"); if (userService.findByUserId(item.getDataChangeLastModifiedBy()) == null) { - throw new BadRequestException("user(dataChangeLastModifiedBy) not exists"); + throw BadRequestException.userNotExists(item.getDataChangeLastModifiedBy()); } if (!StringUtils.isEmpty(item.getComment()) && item.getComment().length() > ITEM_COMMENT_MAX_LENGTH) { @@ -147,12 +148,12 @@ public void deleteItem(@PathVariable String appId, @PathVariable String env, HttpServletRequest request) { if (userService.findByUserId(operator) == null) { - throw new BadRequestException("user(operator) not exists"); + throw BadRequestException.userNotExists(operator); } ItemDTO toDeleteItem = itemService.loadItem(Env.valueOf(env), appId, clusterName, namespaceName, key); if (toDeleteItem == null) { - throw new BadRequestException("item not exists"); + throw NotFoundException.itemNotFound(appId, clusterName, namespaceName, key); } this.itemOpenApiService.removeItem(appId, env, clusterName, namespaceName, key, operator); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/NamespaceBranchController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/NamespaceBranchController.java index d4adba7fa9a..4a0d940e8d3 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/NamespaceBranchController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/NamespaceBranchController.java @@ -88,7 +88,7 @@ public OpenNamespaceDTO createBranch(@PathVariable String appId, RequestPrecondition.checkArguments(!StringUtils.isContainEmpty(operator),"operator can not be empty"); if (userService.findByUserId(operator) == null) { - throw new BadRequestException("operator " + operator + " not exists"); + throw BadRequestException.userNotExists(operator); } NamespaceDTO namespaceDTO = namespaceBranchService.createBranch(appId, Env.valueOf(env.toUpperCase()), clusterName, namespaceName, operator); @@ -110,7 +110,7 @@ public void deleteBranch(@PathVariable String appId, RequestPrecondition.checkArguments(!StringUtils.isContainEmpty(operator),"operator can not be empty"); if (userService.findByUserId(operator) == null) { - throw new BadRequestException("operator " + operator + " not exists"); + throw BadRequestException.userNotExists(operator); } boolean canDelete = consumerPermissionValidator.hasReleaseNamespacePermission(request, appId, namespaceName, env) || @@ -149,7 +149,7 @@ public void updateBranchRules(@PathVariable String appId, @PathVariable String e RequestPrecondition.checkArguments(!StringUtils.isContainEmpty(operator),"operator can not be empty"); if (userService.findByUserId(operator) == null) { - throw new BadRequestException("operator " + operator + " not exists"); + throw BadRequestException.userNotExists(operator); } rules.setAppId(appId); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/NamespaceController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/NamespaceController.java index d060856c21c..822db491fbc 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/NamespaceController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/NamespaceController.java @@ -63,18 +63,17 @@ public OpenAppNamespaceDTO createNamespace(@PathVariable String appId, appNamespaceDTO.getFormat(), appNamespaceDTO.getDataChangeCreatedBy()); if (!InputValidator.isValidAppNamespace(appNamespaceDTO.getName())) { - throw new BadRequestException("Invalid Namespace format: %s", - InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE + " & " + throw BadRequestException.invalidNamespaceFormat(InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE + " & " + InputValidator.INVALID_NAMESPACE_NAMESPACE_MESSAGE); } if (!ConfigFileFormat.isValidFormat(appNamespaceDTO.getFormat())) { - throw new BadRequestException("Invalid namespace format. format = %s", appNamespaceDTO.getFormat()); + throw BadRequestException.invalidNamespaceFormat(appNamespaceDTO.getFormat()); } String operator = appNamespaceDTO.getDataChangeCreatedBy(); if (userService.findByUserId(operator) == null) { - throw new BadRequestException("Illegal user. user = %s", operator); + throw BadRequestException.userNotExists(operator); } return this.namespaceOpenApiService.createAppNamespace(appNamespaceDTO); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ReleaseController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ReleaseController.java index c6c333095e4..1b0067d102b 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ReleaseController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ReleaseController.java @@ -80,7 +80,7 @@ public OpenReleaseDTO createRelease(@PathVariable String appId, @PathVariable St "Params(releaseTitle and releasedBy) can not be empty"); if (userService.findByUserId(model.getReleasedBy()) == null) { - throw new BadRequestException("user(releaseBy) not exists"); + throw BadRequestException.userNotExists(model.getReleasedBy()); } return this.releaseOpenApiService.publishNamespace(appId, env, clusterName, namespaceName, model); @@ -104,7 +104,7 @@ public OpenReleaseDTO merge(@PathVariable String appId, @PathVariable String env "Params(releaseTitle and releasedBy) can not be empty"); if (userService.findByUserId(model.getReleasedBy()) == null) { - throw new BadRequestException("user(releaseBy) not exists"); + throw BadRequestException.userNotExists(model.getReleasedBy()); } ReleaseDTO mergedRelease = namespaceBranchService.merge(appId, Env.valueOf(env.toUpperCase()), clusterName, namespaceName, branchName, @@ -126,7 +126,7 @@ public OpenReleaseDTO createGrayRelease(@PathVariable String appId, "Params(releaseTitle and releasedBy) can not be empty"); if (userService.findByUserId(model.getReleasedBy()) == null) { - throw new BadRequestException("user(releaseBy) not exists"); + throw BadRequestException.userNotExists(model.getReleasedBy()); } NamespaceReleaseModel releaseModel = BeanUtils.transform(NamespaceReleaseModel.class, model); @@ -153,7 +153,7 @@ public OpenReleaseDTO createGrayDelRelease(@PathVariable String appId, "Params(grayDelKeys) can not be null"); if (userService.findByUserId(model.getReleasedBy()) == null) { - throw new BadRequestException("user(releaseBy) not exists"); + throw BadRequestException.userNotExists(model.getReleasedBy()); } NamespaceGrayDelReleaseModel releaseModel = BeanUtils.transform(NamespaceGrayDelReleaseModel.class, model); @@ -172,7 +172,7 @@ public void rollback(@PathVariable String env, "Param operator can not be empty"); if (userService.findByUserId(operator) == null) { - throw new BadRequestException("user(operator) not exists"); + throw BadRequestException.userNotExists(operator); } ReleaseDTO release = releaseService.findReleaseById(Env.valueOf(env), releaseId); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ConsumerController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ConsumerController.java index 78a9a46382b..03f6f16089b 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ConsumerController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ConsumerController.java @@ -105,7 +105,7 @@ public List assignNamespaceRoleToConsumer(@PathVariable String tok continue; } if (Env.UNKNOWN.equals(Env.transformEnv(env))) { - throw new BadRequestException("env: %s is illegal", env); + throw BadRequestException.invalidEnvFormat(env); } envList.add(env); } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ItemController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ItemController.java index 4891bd7ea89..cea43470be3 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ItemController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ItemController.java @@ -130,7 +130,7 @@ public void deleteItem(@PathVariable String appId, @PathVariable String env, // In case someone constructs an attack scenario if (namespace == null || item.getNamespaceId() != namespace.getId()) { - throw new BadRequestException("Invalid request, item and namespace do not match!"); + throw BadRequestException.namespaceNotMatch(); } configService.deleteItem(Env.valueOf(env), itemId, userInfoHolder.getUser().getUserId()); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/NamespaceController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/NamespaceController.java index 14c1056cd4d..c3bbbcadad8 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/NamespaceController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/NamespaceController.java @@ -207,8 +207,7 @@ public AppNamespaceDTO findAppNamespace(@PathVariable String appId, @PathVariabl AppNamespace appNamespace = appNamespaceService.findByAppIdAndName(appId, namespaceName); if (appNamespace == null) { - throw new BadRequestException( - String.format("AppNamespace not exists. AppId = %s, NamespaceName = %s", appId, namespaceName)); + throw BadRequestException.appNamespaceNotExists(appId, namespaceName); } return BeanUtils.transform(AppNamespaceDTO.class, appNamespace); @@ -220,8 +219,8 @@ public AppNamespace createAppNamespace(@PathVariable String appId, @RequestParam(defaultValue = "true") boolean appendNamespacePrefix, @Valid @RequestBody AppNamespace appNamespace) { if (!InputValidator.isValidAppNamespace(appNamespace.getName())) { - throw new BadRequestException("Invalid Namespace format: %s", - InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE + " & " + InputValidator.INVALID_NAMESPACE_NAMESPACE_MESSAGE); + throw BadRequestException.invalidNamespaceFormat(InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE + " & " + + InputValidator.INVALID_NAMESPACE_NAMESPACE_MESSAGE); } AppNamespace createdAppNamespace = appNamespaceService.createAppNamespaceInLocal(appNamespace, appendNamespacePrefix); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/PermissionController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/PermissionController.java index 0887843e420..515fc15c513 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/PermissionController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/PermissionController.java @@ -128,7 +128,7 @@ public NamespaceEnvRolesAssignedUsers getNamespaceEnvRoles(@PathVariable String // validate env parameter if (Env.UNKNOWN == Env.transformEnv(env)) { - throw new BadRequestException("env is illegal"); + throw BadRequestException.invalidEnvFormat(env); } NamespaceEnvRolesAssignedUsers assignedUsers = new NamespaceEnvRolesAssignedUsers(); @@ -155,17 +155,17 @@ public ResponseEntity assignNamespaceEnvRoleToUser(@PathVariable String ap RequestPrecondition.checkArgumentsNotEmpty(user); if (!RoleType.isValidRoleType(roleType)) { - throw new BadRequestException("role type is illegal"); + throw BadRequestException.invalidRoleTypeFormat(roleType); } // validate env parameter if (Env.UNKNOWN == Env.transformEnv(env)) { - throw new BadRequestException("env is illegal"); + throw BadRequestException.invalidEnvFormat(env); } Set assignedUser = rolePermissionService.assignRoleToUsers(RoleUtils.buildNamespaceRoleName(appId, namespaceName, roleType, env), Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); if (CollectionUtils.isEmpty(assignedUser)) { - throw new BadRequestException(user + " already authorized"); + throw BadRequestException.userAlreadyAuthorized(user); } return ResponseEntity.ok().build(); @@ -178,11 +178,11 @@ public ResponseEntity removeNamespaceEnvRoleFromUser(@PathVariable String RequestPrecondition.checkArgumentsNotEmpty(user); if (!RoleType.isValidRoleType(roleType)) { - throw new BadRequestException("role type is illegal"); + throw BadRequestException.invalidRoleTypeFormat(roleType); } // validate env parameter if (Env.UNKNOWN == Env.transformEnv(env)) { - throw new BadRequestException("env is illegal"); + throw BadRequestException.invalidEnvFormat(env); } rolePermissionService.removeRoleFromUsers(RoleUtils.buildNamespaceRoleName(appId, namespaceName, roleType, env), Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); @@ -215,12 +215,12 @@ public ResponseEntity assignNamespaceRoleToUser(@PathVariable String appId RequestPrecondition.checkArgumentsNotEmpty(user); if (!RoleType.isValidRoleType(roleType)) { - throw new BadRequestException("role type is illegal"); + throw BadRequestException.invalidRoleTypeFormat(roleType); } Set assignedUser = rolePermissionService.assignRoleToUsers(RoleUtils.buildNamespaceRoleName(appId, namespaceName, roleType), Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); if (CollectionUtils.isEmpty(assignedUser)) { - throw new BadRequestException(user + " already authorized"); + throw BadRequestException.userAlreadyAuthorized(user); } return ResponseEntity.ok().build(); @@ -233,7 +233,7 @@ public ResponseEntity removeNamespaceRoleFromUser(@PathVariable String app RequestPrecondition.checkArgumentsNotEmpty(user); if (!RoleType.isValidRoleType(roleType)) { - throw new BadRequestException("role type is illegal"); + throw BadRequestException.invalidRoleTypeFormat(roleType); } rolePermissionService.removeRoleFromUsers(RoleUtils.buildNamespaceRoleName(appId, namespaceName, roleType), Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); @@ -259,12 +259,12 @@ public ResponseEntity assignAppRoleToUser(@PathVariable String appId, @Pat RequestPrecondition.checkArgumentsNotEmpty(user); if (!RoleType.isValidRoleType(roleType)) { - throw new BadRequestException("role type is illegal"); + throw BadRequestException.invalidRoleTypeFormat(roleType); } Set assignedUsers = rolePermissionService.assignRoleToUsers(RoleUtils.buildAppRoleName(appId, roleType), Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); if (CollectionUtils.isEmpty(assignedUsers)) { - throw new BadRequestException(user + " already authorized"); + throw BadRequestException.userAlreadyAuthorized(user); } return ResponseEntity.ok().build(); @@ -277,7 +277,7 @@ public ResponseEntity removeAppRoleFromUser(@PathVariable String appId, @P RequestPrecondition.checkArgumentsNotEmpty(user); if (!RoleType.isValidRoleType(roleType)) { - throw new BadRequestException("role type is illegal"); + throw BadRequestException.invalidRoleTypeFormat(roleType); } rolePermissionService.removeRoleFromUsers(RoleUtils.buildAppRoleName(appId, roleType), Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); @@ -286,7 +286,7 @@ public ResponseEntity removeAppRoleFromUser(@PathVariable String appId, @P private void checkUserExists(String userId) { if (userService.findByUserId(userId) == null) { - throw new BadRequestException("User %s does not exist!", userId); + throw BadRequestException.userNotExists(userId); } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ReleaseController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ReleaseController.java index a62f1a5a1b3..ca1292317bd 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ReleaseController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ReleaseController.java @@ -134,7 +134,7 @@ public ReleaseDTO get(@PathVariable String env, ReleaseDTO release = releaseService.findReleaseById(Env.valueOf(env), releaseId); if (release == null) { - throw new NotFoundException("release not found"); + throw NotFoundException.releaseNotFound(releaseId); } return release; } @@ -184,7 +184,7 @@ public void rollback(@PathVariable String env, ReleaseDTO release = releaseService.findReleaseById(Env.valueOf(env), releaseId); if (release == null) { - throw new NotFoundException("release not found"); + throw NotFoundException.releaseNotFound(releaseId); } if (!permissionValidator.hasReleaseNamespacePermission(release.getAppId(), release.getNamespaceName(), env)) { diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/AppNamespaceService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/AppNamespaceService.java index e75ea344d4c..3a2b840baa1 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/AppNamespaceService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/AppNamespaceService.java @@ -130,7 +130,7 @@ public AppNamespace createAppNamespaceInLocal(AppNamespace appNamespace, boolean //add app org id as prefix App app = appService.load(appId); if (app == null) { - throw new BadRequestException("App not exist. AppId = " + appId); + throw BadRequestException.appNotExists(appId); } StringBuilder appNamespaceName = new StringBuilder(); @@ -146,7 +146,7 @@ public AppNamespace createAppNamespaceInLocal(AppNamespace appNamespace, boolean } if (!ConfigFileFormat.isValidFormat(appNamespace.getFormat())) { - throw new BadRequestException("Invalid namespace format. format must be properties、json、yaml、yml、xml"); + throw BadRequestException.invalidNamespaceFormat("format must be properties、json、yaml、yml、xml"); } String operator = appNamespace.getDataChangeCreatedBy(); @@ -233,8 +233,7 @@ private void checkPublicAppNamespaceGlobalUniqueness(AppNamespace appNamespace) public AppNamespace deleteAppNamespace(String appId, String namespaceName) { AppNamespace appNamespace = appNamespaceRepository.findByAppIdAndName(appId, namespaceName); if (appNamespace == null) { - throw new BadRequestException( - String.format("AppNamespace not exists. AppId = %s, NamespaceName = %s", appId, namespaceName)); + throw BadRequestException.appNamespaceNotExists( appId, namespaceName); } String operator = userInfoHolder.getUser().getUserId(); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/AppService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/AppService.java index 0ea470ef998..855537170fa 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/AppService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/AppService.java @@ -130,7 +130,7 @@ public App createAppInLocal(App app) { App managedApp = appRepository.findByAppId(appId); if (managedApp != null) { - throw new BadRequestException("App already exists. AppId = %s", appId); + throw BadRequestException.appAlreadyExists(appId); } UserInfo owner = userService.findByUserId(app.getOwnerName()); @@ -178,7 +178,7 @@ public App updateAppInLocal(App app) { App managedApp = appRepository.findByAppId(appId); if (managedApp == null) { - throw new BadRequestException("App not exists. AppId = %s", appId); + throw BadRequestException.appNotExists(appId); } managedApp.setName(app.getName()); @@ -209,7 +209,7 @@ public EnvClusterInfo createEnvNavNode(Env env, String appId) { public App deleteAppInLocal(String appId) { App managedApp = appRepository.findByAppId(appId); if (managedApp == null) { - throw new BadRequestException("App not exists. AppId = %s", appId); + throw BadRequestException.appNotExists(appId); } String operator = userInfoHolder.getUser().getUserId(); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ClusterService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ClusterService.java index b556d4fdc92..9790eed86b9 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ClusterService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ClusterService.java @@ -44,7 +44,7 @@ public List findClusters(Env env, String appId) { public ClusterDTO createCluster(Env env, ClusterDTO cluster) { if (!clusterAPI.isClusterUnique(cluster.getAppId(), env, cluster.getName())) { - throw new BadRequestException("cluster %s already exists.", cluster.getName()); + throw BadRequestException.clusterAlreadyExists(cluster.getName()); } ClusterDTO clusterDTO = clusterAPI.create(env, cluster); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/FavoriteService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/FavoriteService.java index 4d00dea21ea..b60c46e079c 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/FavoriteService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/FavoriteService.java @@ -52,7 +52,7 @@ public FavoriteService( public Favorite addFavorite(Favorite favorite) { UserInfo user = userService.findByUserId(favorite.getUserId()); if (user == null) { - throw new BadRequestException("user not exist"); + throw BadRequestException.userNotExists(favorite.getUserId()); } UserInfo loginUser = userInfoHolder.getUser(); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ItemService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ItemService.java index 22224f06757..81970c9c38c 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ItemService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ItemService.java @@ -20,6 +20,7 @@ import com.ctrip.framework.apollo.common.constants.GsonType; import com.ctrip.framework.apollo.common.dto.*; import com.ctrip.framework.apollo.common.exception.BadRequestException; +import com.ctrip.framework.apollo.common.exception.NotFoundException; import com.ctrip.framework.apollo.common.utils.BeanUtils; import com.ctrip.framework.apollo.core.enums.ConfigFileFormat; import com.ctrip.framework.apollo.openapi.utils.UrlUtils; @@ -90,14 +91,13 @@ public void updateConfigItemByText(NamespaceTextModel model) { NamespaceDTO namespace = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); if (namespace == null) { - throw new BadRequestException( - "namespace:" + namespaceName + " not exist in env:" + env + ", cluster:" + clusterName); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } long namespaceId = namespace.getId(); // In case someone constructs an attack scenario if (model.getNamespaceId() != namespaceId) { - throw new BadRequestException("Invalid request, item and namespace do not match!"); + throw BadRequestException.namespaceNotExists(); } String configText = model.getConfigText(); @@ -132,8 +132,7 @@ public void updateItems(String appId, Env env, String clusterName, String namesp public ItemDTO createItem(String appId, Env env, String clusterName, String namespaceName, ItemDTO item) { NamespaceDTO namespace = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); if (namespace == null) { - throw new BadRequestException( - "namespace:" + namespaceName + " not exist in env:" + env + ", cluster:" + clusterName); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } item.setNamespaceId(namespace.getId()); @@ -145,8 +144,7 @@ public ItemDTO createItem(String appId, Env env, String clusterName, String name public ItemDTO createCommentItem(String appId, Env env, String clusterName, String namespaceName, ItemDTO item) { NamespaceDTO namespace = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); if (namespace == null) { - throw new BadRequestException( - "namespace:" + namespaceName + " not exist in env:" + env + ", cluster:" + clusterName); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } item.setNamespaceId(namespace.getId()); @@ -179,7 +177,7 @@ public ItemDTO loadItem(Env env, String appId, String clusterName, String namesp public ItemDTO loadItemById(Env env, long itemId) { ItemDTO item = itemAPI.loadItemById(env, itemId); if (item == null) { - throw new BadRequestException("item not found for itemId " + itemId); + throw NotFoundException.itemNotFound(itemId); } return item; } @@ -207,8 +205,7 @@ public void revokeItem(String appId, Env env, String clusterName, String namespa NamespaceDTO namespace = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); if (namespace == null) { - throw new BadRequestException( - "namespace:" + namespaceName + " not exist in env:" + env + ", cluster:" + clusterName); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } long namespaceId = namespace.getId(); @@ -285,9 +282,7 @@ private long getNamespaceId(NamespaceIdentifier namespaceIdentifier) { namespaceDTO = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); } catch (HttpClientErrorException e) { if (e.getStatusCode() == HttpStatus.NOT_FOUND) { - throw new BadRequestException( - "namespace not exist. appId:%s, env:%s, clusterName:%s, namespaceName:%s", appId, env, clusterName, - namespaceName); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } throw e; } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceBranchService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceBranchService.java index 2f90165e196..30940bcfb33 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceBranchService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceBranchService.java @@ -146,7 +146,7 @@ private ItemChangeSets calculateBranchChangeSet(String appId, Env env, String cl NamespaceBO parentNamespace = namespaceService.loadNamespaceBO(appId, env, clusterName, namespaceName); if (parentNamespace == null) { - throw new BadRequestException("base namespace not existed"); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } if (parentNamespace.getItemModifiedCnt() > 0) { diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceService.java index 3c95907c8e7..735ad2a4609 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceService.java @@ -178,7 +178,7 @@ public NamespaceDTO loadNamespaceBaseInfo(String appId, Env env, String clusterN String namespaceName) { NamespaceDTO namespace = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); if (namespace == null) { - throw new BadRequestException("Namespace: %s not exist.", namespaceName); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } return namespace; } @@ -190,7 +190,7 @@ public List findNamespaceBOs(String appId, Env env, String clusterN List namespaces = namespaceAPI.findNamespaceByCluster(appId, env, clusterName); if (namespaces == null || namespaces.size() == 0) { - throw new BadRequestException("namespaces not exist"); + throw BadRequestException.namespaceNotExists(); } List namespaceBOs = Collections.synchronizedList(new LinkedList<>()); @@ -253,7 +253,7 @@ public NamespaceBO loadNamespaceBO(String appId, Env env, String clusterName, String namespaceName, boolean includeDeletedItems) { NamespaceDTO namespace = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); if (namespace == null) { - throw new BadRequestException("namespaces not exist"); + throw BadRequestException.namespaceNotExists(appId, clusterName, namespaceName); } return transformNamespace2BO(env, namespace, includeDeletedItems); } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/spi/springsecurity/SpringSecurityUserService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/spi/springsecurity/SpringSecurityUserService.java index 04c5ea129d5..ab0e183d254 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/spi/springsecurity/SpringSecurityUserService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/spi/springsecurity/SpringSecurityUserService.java @@ -62,7 +62,7 @@ public void create(UserPO user) { String newPassword = passwordEncoder.encode(user.getPassword()); UserPO managedUser = userRepository.findByUsername(username); if (managedUser != null) { - throw new BadRequestException("User %s already exists", username); + throw BadRequestException.userAlreadyExists(username); } //create user.setPassword(newPassword); @@ -82,7 +82,7 @@ public void update(UserPO user) { String newPassword = passwordEncoder.encode(user.getPassword()); UserPO managedUser = userRepository.findByUsername(username); if (managedUser == null) { - throw new BadRequestException("User does not exist, please create a new user."); + throw BadRequestException.userNotExists(username); } managedUser.setPassword(newPassword); managedUser.setEmail(user.getEmail()); diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerServiceIntegrationTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerServiceIntegrationTest.java index 7d04fcb9fcd..6c89d01a4fc 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerServiceIntegrationTest.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerServiceIntegrationTest.java @@ -23,13 +23,10 @@ import com.ctrip.framework.apollo.openapi.entity.Consumer; import com.ctrip.framework.apollo.portal.AbstractIntegrationTest; import com.google.common.collect.Sets; -import java.util.Collections; import java.util.List; import java.util.Set; import org.assertj.core.api.Assertions; -import org.junit.Assert; import org.junit.Test; -import org.junit.function.ThrowingRunnable; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.domain.Pageable; import org.springframework.test.context.jdbc.Sql; diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/controller/ItemControllerTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/controller/ItemControllerTest.java index 73ea6ec80b4..08f1038c800 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/controller/ItemControllerTest.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/controller/ItemControllerTest.java @@ -33,8 +33,6 @@ import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; -import org.yaml.snakeyaml.constructor.ConstructorException; -import org.yaml.snakeyaml.constructor.DuplicateKeyException; @RunWith(MockitoJUnitRunner.class) public class ItemControllerTest { diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/ConfigServiceTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/ConfigServiceTest.java index 2d60e37e413..eb7684671e7 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/ConfigServiceTest.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/ConfigServiceTest.java @@ -33,7 +33,6 @@ import com.ctrip.framework.apollo.portal.entity.vo.NamespaceIdentifier; import java.util.Collections; -import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.InjectMocks;