openapi support create and load cluster info (#2590)

openapi support create and load cluster info

apollo-openapi/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenClusterDTO.java

+package com.ctrip.framework.apollo.openapi.dto;
+
+public class OpenClusterDTO extends BaseDTO {
+
+  private String name;
+
+  private String appId;
+
+  public String getName() {
+    return name;
+  }
+
+  public void setName(String name) {
+    this.name = name;
+  }
+
+  public String getAppId() {
+    return appId;
+  }
+
+  public void setAppId(String appId) {
+    this.appId = appId;
+  }
+}

apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/auth/ConsumerPermissionValidator.java

@@ -5,7 +5,6 @@ import com.ctrip.framework.apollo.openapi.util.ConsumerAuthUtil;
 import com.ctrip.framework.apollo.portal.constant.PermissionType;
 import com.ctrip.framework.apollo.portal.util.RoleUtils;
 import org.springframework.stereotype.Component;
-
 import javax.servlet.http.HttpServletRequest;
 
 @Component
@@ -14,45 +13,45 @@ public class ConsumerPermissionValidator {
   private final ConsumerRolePermissionService permissionService;
   private final ConsumerAuthUtil consumerAuthUtil;
 
-  public ConsumerPermissionValidator(
-      final ConsumerRolePermissionService permissionService,
+  public ConsumerPermissionValidator(final ConsumerRolePermissionService permissionService,
       final ConsumerAuthUtil consumerAuthUtil) {
     this.permissionService = permissionService;
     this.consumerAuthUtil = consumerAuthUtil;
   }
 
-  public boolean hasModifyNamespacePermission(HttpServletRequest request, String appId, String namespaceName,
-      String env) {
+  public boolean hasModifyNamespacePermission(HttpServletRequest request, String appId,
+      String namespaceName, String env) {
     if (hasCreateNamespacePermission(request, appId)) {
       return true;
     }
     return permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request),
         PermissionType.MODIFY_NAMESPACE, RoleUtils.buildNamespaceTargetId(appId, namespaceName))
-        ||
-        permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request),
-        PermissionType.MODIFY_NAMESPACE, RoleUtils.buildNamespaceTargetId(appId, namespaceName, env));
+        || permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request),
+            PermissionType.MODIFY_NAMESPACE,
+            RoleUtils.buildNamespaceTargetId(appId, namespaceName, env));
 
   }
 
-  public boolean hasReleaseNamespacePermission(HttpServletRequest request, String appId, String namespaceName,
-      String env) {
+  public boolean hasReleaseNamespacePermission(HttpServletRequest request, String appId,
+      String namespaceName, String env) {
     if (hasCreateNamespacePermission(request, appId)) {
       return true;
     }
     return permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request),
-        PermissionType.RELEASE_NAMESPACE,
-        RoleUtils.buildNamespaceTargetId(appId, namespaceName))
-        ||
-        permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request),
-        PermissionType.RELEASE_NAMESPACE,
-        RoleUtils.buildNamespaceTargetId(appId, namespaceName, env));
+        PermissionType.RELEASE_NAMESPACE, RoleUtils.buildNamespaceTargetId(appId, namespaceName))
+        || permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request),
+            PermissionType.RELEASE_NAMESPACE,
+            RoleUtils.buildNamespaceTargetId(appId, namespaceName, env));
 
   }
 
   public boolean hasCreateNamespacePermission(HttpServletRequest request, String appId) {
     return permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request),
-                                                   PermissionType.CREATE_NAMESPACE,
-                                                   appId);
+        PermissionType.CREATE_NAMESPACE, appId);
   }
 
+  public boolean hasCreateClusterPermission(HttpServletRequest request, String appId) {
+    return permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request),
+        PermissionType.CREATE_CLUSTER, appId);
+  }
 }

apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/util/OpenApiBeanUtils.java

 package com.ctrip.framework.apollo.openapi.util;
 
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.springframework.util.CollectionUtils;
+import com.ctrip.framework.apollo.common.dto.ClusterDTO;
 import com.ctrip.framework.apollo.common.dto.GrayReleaseRuleDTO;
 import com.ctrip.framework.apollo.common.dto.GrayReleaseRuleItemDTO;
 import com.ctrip.framework.apollo.common.dto.ItemDTO;
@@ -10,6 +19,7 @@ import com.ctrip.framework.apollo.common.entity.AppNamespace;
 import com.ctrip.framework.apollo.common.utils.BeanUtils;
 import com.ctrip.framework.apollo.openapi.dto.OpenAppDTO;
 import com.ctrip.framework.apollo.openapi.dto.OpenAppNamespaceDTO;
+import com.ctrip.framework.apollo.openapi.dto.OpenClusterDTO;
 import com.ctrip.framework.apollo.openapi.dto.OpenGrayReleaseRuleDTO;
 import com.ctrip.framework.apollo.openapi.dto.OpenGrayReleaseRuleItemDTO;
 import com.ctrip.framework.apollo.openapi.dto.OpenItemDTO;
@@ -21,21 +31,11 @@ import com.ctrip.framework.apollo.portal.entity.bo.NamespaceBO;
 import com.google.common.base.Preconditions;
 import com.google.common.reflect.TypeToken;
 import com.google.gson.Gson;
-import org.springframework.util.CollectionUtils;
-
-import java.lang.reflect.Type;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
 
 public class OpenApiBeanUtils {
 
   private static Gson gson = new Gson();
-  private static Type type = new TypeToken<Map<String, String>>() {
-  }.getType();
+  private static Type type = new TypeToken<Map<String, String>>() {}.getType();
 
   public static OpenItemDTO transformFromItemDTO(ItemDTO item) {
     Preconditions.checkArgument(item != null);
@@ -71,28 +71,28 @@ public class OpenApiBeanUtils {
   public static OpenNamespaceDTO transformFromNamespaceBO(NamespaceBO namespaceBO) {
     Preconditions.checkArgument(namespaceBO != null);
 
-    OpenNamespaceDTO openNamespaceDTO = BeanUtils.transform(OpenNamespaceDTO.class, namespaceBO
-        .getBaseInfo());
+    OpenNamespaceDTO openNamespaceDTO =
+        BeanUtils.transform(OpenNamespaceDTO.class, namespaceBO.getBaseInfo());
 
-    //app namespace info
+    // app namespace info
     openNamespaceDTO.setFormat(namespaceBO.getFormat());
     openNamespaceDTO.setComment(namespaceBO.getComment());
     openNamespaceDTO.setPublic(namespaceBO.isPublic());
 
-    //items
+    // items
     List<OpenItemDTO> items = new LinkedList<>();
     List<ItemBO> itemBOs = namespaceBO.getItems();
     if (!CollectionUtils.isEmpty(itemBOs)) {
-      items.addAll(itemBOs.stream().map(itemBO -> transformFromItemDTO(itemBO.getItem())).collect
-          (Collectors.toList()));
+      items.addAll(itemBOs.stream().map(itemBO -> transformFromItemDTO(itemBO.getItem()))
+          .collect(Collectors.toList()));
     }
     openNamespaceDTO.setItems(items);
     return openNamespaceDTO;
 
   }
 
-  public static List<OpenNamespaceDTO> batchTransformFromNamespaceBOs(List<NamespaceBO>
-                                                                          namespaceBOs) {
+  public static List<OpenNamespaceDTO> batchTransformFromNamespaceBOs(
+      List<NamespaceBO> namespaceBOs) {
     if (CollectionUtils.isEmpty(namespaceBOs)) {
       return Collections.emptyList();
     }
@@ -105,8 +105,7 @@ public class OpenApiBeanUtils {
   }
 
   public static OpenNamespaceLockDTO transformFromNamespaceLockDTO(String namespaceName,
-                                                                   NamespaceLockDTO
-                                                                       namespaceLock) {
+      NamespaceLockDTO namespaceLock) {
     OpenNamespaceLockDTO lock = new OpenNamespaceLockDTO();
 
     lock.setNamespaceName(namespaceName);
@@ -121,13 +120,15 @@ public class OpenApiBeanUtils {
     return lock;
   }
 
-  public static OpenGrayReleaseRuleDTO transformFromGrayReleaseRuleDTO(GrayReleaseRuleDTO grayReleaseRuleDTO){
+  public static OpenGrayReleaseRuleDTO transformFromGrayReleaseRuleDTO(
+      GrayReleaseRuleDTO grayReleaseRuleDTO) {
     Preconditions.checkArgument(grayReleaseRuleDTO != null);
 
     return BeanUtils.transform(OpenGrayReleaseRuleDTO.class, grayReleaseRuleDTO);
   }
 
-  public static GrayReleaseRuleDTO transformToGrayReleaseRuleDTO(OpenGrayReleaseRuleDTO openGrayReleaseRuleDTO){
+  public static GrayReleaseRuleDTO transformToGrayReleaseRuleDTO(
+      OpenGrayReleaseRuleDTO openGrayReleaseRuleDTO) {
     Preconditions.checkArgument(openGrayReleaseRuleDTO != null);
 
     String appId = openGrayReleaseRuleDTO.getAppId();
@@ -135,10 +136,12 @@ public class OpenApiBeanUtils {
     String clusterName = openGrayReleaseRuleDTO.getClusterName();
     String namespaceName = openGrayReleaseRuleDTO.getNamespaceName();
 
-    GrayReleaseRuleDTO grayReleaseRuleDTO = new GrayReleaseRuleDTO(appId,clusterName,namespaceName,branchName);
+    GrayReleaseRuleDTO grayReleaseRuleDTO =
+        new GrayReleaseRuleDTO(appId, clusterName, namespaceName, branchName);
 
-    Set<OpenGrayReleaseRuleItemDTO> openGrayReleaseRuleItemDTOSet = openGrayReleaseRuleDTO.getRuleItems();
-    openGrayReleaseRuleItemDTOSet.forEach(openGrayReleaseRuleItemDTO ->{
+    Set<OpenGrayReleaseRuleItemDTO> openGrayReleaseRuleItemDTOSet =
+        openGrayReleaseRuleDTO.getRuleItems();
+    openGrayReleaseRuleItemDTOSet.forEach(openGrayReleaseRuleItemDTO -> {
       String clientAppId = openGrayReleaseRuleItemDTO.getClientAppId();
       Set<String> clientIpList = openGrayReleaseRuleItemDTO.getClientIpList();
       GrayReleaseRuleItemDTO ruleItem = new GrayReleaseRuleItemDTO(clientAppId, clientIpList);
@@ -152,9 +155,7 @@ public class OpenApiBeanUtils {
     if (CollectionUtils.isEmpty(apps)) {
       return Collections.emptyList();
     }
-    return apps.stream()
-        .map(OpenApiBeanUtils::transformFromApp)
-        .collect(Collectors.toList());
+    return apps.stream().map(OpenApiBeanUtils::transformFromApp).collect(Collectors.toList());
   }
 
   public static OpenAppDTO transformFromApp(final App app) {
@@ -162,4 +163,14 @@ public class OpenApiBeanUtils {
 
     return BeanUtils.transform(OpenAppDTO.class, app);
   }
+
+  public static OpenClusterDTO transformFromClusterDTO(ClusterDTO Cluster) {
+    Preconditions.checkArgument(Cluster != null);
+    return BeanUtils.transform(OpenClusterDTO.class, Cluster);
+  }
+
+  public static ClusterDTO transformToClusterDTO(OpenClusterDTO openClusterDTO) {
+    Preconditions.checkArgument(openClusterDTO != null);
+    return BeanUtils.transform(ClusterDTO.class, openClusterDTO);
+  }
 }

apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ClusterController.java

+package com.ctrip.framework.apollo.openapi.v1.controller;
+
+import java.util.Objects;
+import javax.servlet.http.HttpServletRequest;
+import javax.validation.Valid;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import com.ctrip.framework.apollo.common.dto.ClusterDTO;
+import com.ctrip.framework.apollo.common.exception.BadRequestException;
+import com.ctrip.framework.apollo.common.utils.InputValidator;
+import com.ctrip.framework.apollo.common.utils.RequestPrecondition;
+import com.ctrip.framework.apollo.core.enums.Env;
+import com.ctrip.framework.apollo.core.utils.StringUtils;
+import com.ctrip.framework.apollo.openapi.dto.OpenClusterDTO;
+import com.ctrip.framework.apollo.openapi.util.OpenApiBeanUtils;
+import com.ctrip.framework.apollo.portal.service.ClusterService;
+import com.ctrip.framework.apollo.portal.spi.UserService;
+
+@RestController("openapiClusterController")
+@RequestMapping("/openapi/v1/envs/{env}")
+public class ClusterController {
+
+  private final ClusterService clusterService;
+  private final UserService userService;
+
+  public ClusterController(final ClusterService clusterService, final UserService userService) {
+    this.clusterService = clusterService;
+    this.userService = userService;
+  }
+
+  @GetMapping(value = "apps/{appId}/clusters/{clusterName:.+}")
+  public OpenClusterDTO loadCluster(@PathVariable("appId") String appId, @PathVariable String env,
+      @PathVariable("clusterName") String clusterName) {
+
+    ClusterDTO clusterDTO = clusterService.loadCluster(appId, Env.fromString(env), clusterName);
+    return clusterDTO == null ? null : OpenApiBeanUtils.transformFromClusterDTO(clusterDTO);
+  }
+
+  @PreAuthorize(value = "@consumerPermissionValidator.hasCreateClusterPermission(#request, #appId)")
+  @PostMapping(value = "apps/{appId}/clusters")
+  public OpenClusterDTO createCluster(@PathVariable String appId, @PathVariable String env,
+      @Valid @RequestBody OpenClusterDTO cluster, HttpServletRequest request) {
+
+    if (!Objects.equals(appId, cluster.getAppId())) {
+      throw new BadRequestException(String.format(
+          "AppId not equal. AppId in path = %s, AppId in payload = %s", appId, cluster.getAppId()));
+    }
+
+    String clusterName = cluster.getName();
+    String operator = cluster.getDataChangeCreatedBy();
+
+    RequestPrecondition.checkArguments(!StringUtils.isContainEmpty(clusterName, operator),
+        "name and dataChangeCreatedBy should not be null or empty");
+
+    if (!InputValidator.isValidAppNamespace(clusterName)) {
+      throw new BadRequestException(
+          String.format("Cluster Name 格式错误: %s", InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE
+              + " & " + InputValidator.INVALID_NAMESPACE_NAMESPACE_MESSAGE));
+    }
+
+    if (userService.findByUserId(operator) == null) {
+      throw new BadRequestException("User " + operator + " doesn't exist!");
+    }
+
+    ClusterDTO toCreate = OpenApiBeanUtils.transformToClusterDTO(cluster);
+    ClusterDTO createdClusterDTO = clusterService.createCluster(Env.valueOf(env), toCreate);
+
+    return OpenApiBeanUtils.transformFromClusterDTO(createdClusterDTO);
+  }
+
+}