diff --git a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceLockAspect.java b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceLockAspect.java index 67c8b2cfeff30ce5d980b91ec4c8ee4b73494d4e..6c78862cbcab2471946d3c37fe910b918821db73 100644 --- a/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceLockAspect.java +++ b/apollo-adminservice/src/main/java/com/ctrip/framework/apollo/adminservice/aop/NamespaceLockAspect.java @@ -67,7 +67,9 @@ public class NamespaceLockAspect { @Before("@annotation(PreAcquireNamespaceLock) && args(itemId, operator, ..)") public void requireLockAdvice(long itemId, String operator) { Item item = itemService.findOne(itemId); - + if (item == null){ + throw new BadRequestException("item not exist."); + } acquireLock(item.getNamespaceId(), operator); } diff --git a/apollo-assembly/src/main/java/com/ctrip/framework/apollo/assembly/ApolloApplication.java b/apollo-assembly/src/main/java/com/ctrip/framework/apollo/assembly/ApolloApplication.java index a392e09726d5e56869885977371a0da4f790d47a..85b6e984a351a497d1319ea82dc88e07501c5c4d 100644 --- a/apollo-assembly/src/main/java/com/ctrip/framework/apollo/assembly/ApolloApplication.java +++ b/apollo-assembly/src/main/java/com/ctrip/framework/apollo/assembly/ApolloApplication.java @@ -12,7 +12,6 @@ import org.springframework.context.ConfigurableApplicationContext; import com.ctrip.framework.apollo.adminservice.AdminServiceApplication; import com.ctrip.framework.apollo.configservice.ConfigServiceApplication; -import com.ctrip.framework.apollo.portal.PortalApplication; @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class}) diff --git a/apollo-assembly/src/test/java/com/ctrip/framework/apollo/assembly/LocalApolloApplication.java b/apollo-assembly/src/test/java/com/ctrip/framework/apollo/assembly/LocalApolloApplication.java index 7a9d9554c6a2e3d32a32dd3a69d15b96d503dbfc..31949683aaf90d22d18e5e59804f916236686a3b 100644 --- a/apollo-assembly/src/test/java/com/ctrip/framework/apollo/assembly/LocalApolloApplication.java +++ b/apollo-assembly/src/test/java/com/ctrip/framework/apollo/assembly/LocalApolloApplication.java @@ -12,7 +12,7 @@ import org.springframework.context.ConfigurableApplicationContext; import com.ctrip.framework.apollo.adminservice.AdminServiceApplication; import com.ctrip.framework.apollo.configservice.ConfigServiceApplication; -import com.ctrip.framework.apollo.portal.PortalApplication; +import com.ctrip.framework.apollo.PortalApplication; @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class}) diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AppNamespaceService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AppNamespaceService.java index 7aa14313ac10d886f2ed93715deff504443a78b7..bed0213c7114007cf1ab368200fb61c02d1057d8 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AppNamespaceService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/AppNamespaceService.java @@ -50,7 +50,7 @@ public class AppNamespaceService { public List findPublicNamespacesByNames(Set namespaceNames) { if (namespaceNames == null || namespaceNames.isEmpty()) { - return Collections.EMPTY_LIST; + return Collections.emptyList(); } return appNamespaceRepository.findByNameInAndIsPublicTrue(namespaceNames); @@ -68,7 +68,7 @@ public class AppNamespaceService { public List findByAppIdAndNamespaces(String appId, Set namespaceNames) { Preconditions.checkArgument(!Strings.isNullOrEmpty(appId), "appId must not be null"); if (namespaceNames == null || namespaceNames.isEmpty()) { - return Collections.EMPTY_LIST; + return Collections.emptyList(); } return appNamespaceRepository.findByAppIdAndNameIn(appId, namespaceNames); } diff --git a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ReleaseMessageService.java b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ReleaseMessageService.java index 4c6cfb14dea4511ca458fc1d8dd61c3094d5b7cc..e9e4288b0cb00ecf5b444508a71787670ad9949d 100644 --- a/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ReleaseMessageService.java +++ b/apollo-biz/src/main/java/com/ctrip/framework/apollo/biz/service/ReleaseMessageService.java @@ -32,7 +32,7 @@ public class ReleaseMessageService { public List findLatestReleaseMessagesGroupByMessages(Collection messages) { if (CollectionUtils.isEmpty(messages)) { - return Collections.EMPTY_LIST; + return Collections.emptyList(); } List result = releaseMessageRepository.findLatestReleaseMessagesGroupByMessages(messages); diff --git a/apollo-common/pom.xml b/apollo-common/pom.xml index d078e273aa002b547d5fb858519d39dedc4cc693..69799d02a0b7f7021ffa2eb76a38f72f659124a7 100644 --- a/apollo-common/pom.xml +++ b/apollo-common/pom.xml @@ -54,5 +54,9 @@ ch.qos.logback logback-classic + + commons-lang + commons-lang + diff --git a/apollo-common/src/main/java/com/ctrip/framework/apollo/common/controller/GlobalDefaultExceptionHandler.java b/apollo-common/src/main/java/com/ctrip/framework/apollo/common/controller/GlobalDefaultExceptionHandler.java index c8e0011deb0266928008dd83ebc4752dd77283df..4d5ce51da914e4d1395003308fa5bdeca83eab86 100644 --- a/apollo-common/src/main/java/com/ctrip/framework/apollo/common/controller/GlobalDefaultExceptionHandler.java +++ b/apollo-common/src/main/java/com/ctrip/framework/apollo/common/controller/GlobalDefaultExceptionHandler.java @@ -1,5 +1,8 @@ package com.ctrip.framework.apollo.common.controller; +import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; + import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.http.HttpHeaders; @@ -15,6 +18,7 @@ import org.springframework.web.client.HttpStatusCodeException; import com.ctrip.framework.apollo.common.exception.AbstractApolloHttpException; import com.dianping.cat.Cat; +import java.lang.reflect.Type; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; import java.util.HashMap; @@ -24,70 +28,80 @@ import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import static org.springframework.http.HttpStatus.BAD_REQUEST; +import static org.springframework.http.HttpStatus.FORBIDDEN; import static org.springframework.http.HttpStatus.INTERNAL_SERVER_ERROR; -import static org.springframework.http.HttpStatus.UNAUTHORIZED; import static org.springframework.http.MediaType.APPLICATION_JSON; @ControllerAdvice public class GlobalDefaultExceptionHandler { - - private static final Logger logger = LoggerFactory.getLogger(GlobalDefaultExceptionHandler.class); - - //处理系统内置的Exception - @ExceptionHandler(Throwable.class) - public ResponseEntity> exception(HttpServletRequest request, Throwable ex) { - return handleError(request, INTERNAL_SERVER_ERROR, ex); - } - - @ExceptionHandler({HttpRequestMethodNotSupportedException.class, HttpMediaTypeException.class}) - public ResponseEntity> badRequest(HttpServletRequest request, - ServletException ex) { - return handleError(request, BAD_REQUEST, ex); - } - - @ExceptionHandler(HttpStatusCodeException.class) - public ResponseEntity> restTemplateException(HttpServletRequest request, - HttpStatusCodeException ex) { - return handleError(request, ex.getStatusCode(), ex); - } - - @ExceptionHandler(AccessDeniedException.class) - public ResponseEntity> accessDeny(HttpServletRequest request, - AccessDeniedException ex) { - return handleError(request, UNAUTHORIZED, ex); - } - - //处理自定义Exception - @ExceptionHandler({AbstractApolloHttpException.class}) - public ResponseEntity> badRequest(HttpServletRequest request, AbstractApolloHttpException ex) { - return handleError(request, ex); - } - - - private ResponseEntity> handleError(HttpServletRequest request, - AbstractApolloHttpException ex) { - return handleError(request, ex.getHttpStatus(), ex); - } - - - private ResponseEntity> handleError(HttpServletRequest request, - HttpStatus status, Throwable ex) { - String message = ex.getMessage(); - - logger.error(message, ex); - Cat.logError(ex); - - Map errorAttributes = new HashMap<>(); - - errorAttributes.put("status", status.value()); - errorAttributes.put("message", message); - errorAttributes.put("timestamp", - LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)); - errorAttributes.put("exception", ex.getClass().getName()); - - HttpHeaders headers = new HttpHeaders(); - headers.setContentType(APPLICATION_JSON); - return new ResponseEntity<>(errorAttributes, headers, status); - } + private Gson gson = new Gson(); + private static Type mapType = new TypeToken>() {}.getType(); + + private static final Logger logger = LoggerFactory.getLogger(GlobalDefaultExceptionHandler.class); + + //处理系统内置的Exception + @ExceptionHandler(Throwable.class) + public ResponseEntity> exception(HttpServletRequest request, Throwable ex) { + return handleError(request, INTERNAL_SERVER_ERROR, ex); + } + + @ExceptionHandler({HttpRequestMethodNotSupportedException.class, HttpMediaTypeException.class}) + public ResponseEntity> badRequest(HttpServletRequest request, + ServletException ex) { + return handleError(request, BAD_REQUEST, ex); + } + + @ExceptionHandler(HttpStatusCodeException.class) + public ResponseEntity> restTemplateException(HttpServletRequest request, + HttpStatusCodeException ex) { + return handleError(request, ex.getStatusCode(), ex); + } + + @ExceptionHandler(AccessDeniedException.class) + public ResponseEntity> accessDeny(HttpServletRequest request, + AccessDeniedException ex) { + return handleError(request, FORBIDDEN, ex); + } + + //处理自定义Exception + @ExceptionHandler({AbstractApolloHttpException.class}) + public ResponseEntity> badRequest(HttpServletRequest request, AbstractApolloHttpException ex) { + return handleError(request, ex); + } + + + private ResponseEntity> handleError(HttpServletRequest request, + AbstractApolloHttpException ex) { + return handleError(request, ex.getHttpStatus(), ex); + } + + + private ResponseEntity> handleError(HttpServletRequest request, + HttpStatus status, Throwable ex) { + String message = ex.getMessage(); + + logger.error(message, ex); + Cat.logError(ex); + + + Map errorAttributes = new HashMap<>(); + + //如果是admin server引起的异常,则显示内部的异常信息 + if (ex instanceof HttpStatusCodeException){ + errorAttributes = gson.fromJson(((HttpStatusCodeException)ex).getResponseBodyAsString(), mapType); + status = ((HttpStatusCodeException)ex).getStatusCode(); + } else { + errorAttributes.put("status", status.value()); + errorAttributes.put("message", message); + errorAttributes.put("timestamp", + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)); + errorAttributes.put("exception", ex.getClass().getName()); + + } + + HttpHeaders headers = new HttpHeaders(); + headers.setContentType(APPLICATION_JSON); + return new ResponseEntity<>(errorAttributes, headers, status); + } } diff --git a/apollo-common/src/main/java/com/ctrip/framework/apollo/common/utils/RequestPrecondition.java b/apollo-common/src/main/java/com/ctrip/framework/apollo/common/utils/RequestPrecondition.java index 26de753a9fd17bd0714b3883f84b10f24f54a61f..fe18b468963e58557d18c3abd0774af71bfc8501 100644 --- a/apollo-common/src/main/java/com/ctrip/framework/apollo/common/utils/RequestPrecondition.java +++ b/apollo-common/src/main/java/com/ctrip/framework/apollo/common/utils/RequestPrecondition.java @@ -14,15 +14,15 @@ public class RequestPrecondition { private static String ILLEGAL_NUMBER = "number should be positive"; - public static void checkArgument(String... args) { - checkArgument(!StringUtils.isContainEmpty(args), CONTAIN_EMPTY_ARGUMENT); + public static void checkArgumentsNotEmpty(String... args) { + checkArguments(!StringUtils.isContainEmpty(args), CONTAIN_EMPTY_ARGUMENT); } public static void checkModel(boolean valid){ - checkArgument(valid, ILLEGAL_MODEL); + checkArguments(valid, ILLEGAL_MODEL); } - public static void checkArgument(boolean expression, Object errorMessage) { + public static void checkArguments(boolean expression, Object errorMessage) { if (!expression) { throw new BadRequestException(String.valueOf(errorMessage)); } @@ -36,6 +36,14 @@ public class RequestPrecondition { } } + public static void checkNumberPositive(long... args){ + for (long num: args){ + if (num <= 0){ + throw new BadRequestException(ILLEGAL_NUMBER); + } + } + } + public static void checkNumberNotNegative(int... args){ for (int num: args){ if (num < 0){ diff --git a/apollo-core/src/main/java/com/ctrip/framework/apollo/core/enums/Env.java b/apollo-core/src/main/java/com/ctrip/framework/apollo/core/enums/Env.java index 1b4f5bb3af281e16cec9318c5253c86830bd4712..5541d41ded02c15e9ccb2b129d38b80b86642816 100644 --- a/apollo-core/src/main/java/com/ctrip/framework/apollo/core/enums/Env.java +++ b/apollo-core/src/main/java/com/ctrip/framework/apollo/core/enums/Env.java @@ -1,8 +1,16 @@ package com.ctrip.framework.apollo.core.enums; +import com.google.common.base.Preconditions; + /** * @author Jason Song(song_s@ctrip.com) */ public enum Env{ - LOCAL, DEV, FWS, FAT, UAT, LPT, PRO, TOOLS + LOCAL, DEV, FWS, FAT, UAT, LPT, PRO, TOOLS; + + public static Env fromString(String env) { + Env environment = EnvUtils.transformEnv(env); + Preconditions.checkArgument(environment != null, String.format("Env %s is invalid", env)); + return environment; + } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/PortalApplication.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/PortalApplication.java similarity index 89% rename from apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/PortalApplication.java rename to apollo-portal/src/main/java/com/ctrip/framework/apollo/PortalApplication.java index c799e43725b603b75c244c7aff06938916bafa12..aa20abe040ff5a33239fad79175d37865858a107 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/PortalApplication.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/PortalApplication.java @@ -1,4 +1,4 @@ -package com.ctrip.framework.apollo.portal; +package com.ctrip.framework.apollo; import com.ctrip.framework.apollo.common.ApolloCommonConfig; @@ -16,8 +16,7 @@ import org.springframework.transaction.annotation.EnableTransactionManagement; @Configuration @EnableAutoConfiguration @EnableTransactionManagement -@ComponentScan(basePackageClasses = {ApolloCommonConfig.class, - PortalApplication.class}) +@ComponentScan(basePackageClasses = {ApolloCommonConfig.class, PortalApplication.class}) public class PortalApplication { public static void main(String[] args) throws Exception { diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/auth/ConsumerPermissionValidator.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/auth/ConsumerPermissionValidator.java new file mode 100644 index 0000000000000000000000000000000000000000..c014500569e1b41f209a9649aa3aac09136a557e --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/auth/ConsumerPermissionValidator.java @@ -0,0 +1,37 @@ +package com.ctrip.framework.apollo.openapi.auth; + +import com.ctrip.framework.apollo.openapi.service.ConsumerRolePermissionService; +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.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import javax.servlet.http.HttpServletRequest; + +@Component +public class ConsumerPermissionValidator { + + @Autowired + private ConsumerRolePermissionService permissionService; + @Autowired + private ConsumerAuthUtil consumerAuthUtil; + + public boolean hasModifyNamespacePermission(HttpServletRequest request, String appId, String + namespaceName) { + return permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request), + PermissionType.MODIFY_NAMESPACE, + RoleUtils.buildNamespaceTargetId(appId, namespaceName)); + + } + + public boolean hasReleaseNamespacePermission(HttpServletRequest request, String appId, String + namespaceName) { + return permissionService.consumerHasPermission(consumerAuthUtil.retrieveConsumerId(request), + PermissionType.RELEASE_NAMESPACE, + RoleUtils.buildNamespaceTargetId(appId, namespaceName)); + + } + +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenItemDTO.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenItemDTO.java new file mode 100644 index 0000000000000000000000000000000000000000..26731216ec4981fca73397004b5e6e266cb57415 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenItemDTO.java @@ -0,0 +1,46 @@ +package com.ctrip.framework.apollo.openapi.dto; + +import com.ctrip.framework.apollo.common.dto.BaseDTO; + +public class OpenItemDTO extends BaseDTO { + + private long id; + + private String key; + + private String value; + + private String comment; + + public long getId() { + return id; + } + + public void setId(long id) { + this.id = id; + } + + public String getKey() { + return key; + } + + public void setKey(String key) { + this.key = key; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } + + public String getComment() { + return comment; + } + + public void setComment(String comment) { + this.comment = comment; + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenNamespaceDTO.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenNamespaceDTO.java new file mode 100644 index 0000000000000000000000000000000000000000..70658795e8ee5696f54af3cf86c9bb4f8615b168 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenNamespaceDTO.java @@ -0,0 +1,78 @@ +package com.ctrip.framework.apollo.openapi.dto; + +import com.ctrip.framework.apollo.common.dto.BaseDTO; + +import java.util.List; + +public class OpenNamespaceDTO extends BaseDTO { + + private String appId; + + private String clusterName; + + private String namespaceName; + + private String comment; + + private String format; + + private boolean isPublic; + + private List items; + + public String getAppId() { + return appId; + } + + public void setAppId(String appId) { + this.appId = appId; + } + + public String getClusterName() { + return clusterName; + } + + public void setClusterName(String clusterName) { + this.clusterName = clusterName; + } + + public String getNamespaceName() { + return namespaceName; + } + + public void setNamespaceName(String namespaceName) { + this.namespaceName = namespaceName; + } + + public String getComment() { + return comment; + } + + public void setComment(String comment) { + this.comment = comment; + } + + public String getFormat() { + return format; + } + + public void setFormat(String format) { + this.format = format; + } + + public boolean isPublic() { + return isPublic; + } + + public void setPublic(boolean aPublic) { + isPublic = aPublic; + } + + public List getItems() { + return items; + } + + public void setItems(List items) { + this.items = items; + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenNamespaceLockDTO.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenNamespaceLockDTO.java new file mode 100644 index 0000000000000000000000000000000000000000..2cdb7f0119ec67537a11be92cc763ba782400e0b --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenNamespaceLockDTO.java @@ -0,0 +1,32 @@ +package com.ctrip.framework.apollo.openapi.dto; + +public class OpenNamespaceLockDTO { + + private String namespaceName; + private boolean isLocked; + private String lockedBy; + + public String getNamespaceName() { + return namespaceName; + } + + public void setNamespaceName(String namespaceName) { + this.namespaceName = namespaceName; + } + + public boolean isLocked() { + return isLocked; + } + + public void setLocked(boolean locked) { + isLocked = locked; + } + + public String getLockedBy() { + return lockedBy; + } + + public void setLockedBy(String lockedBy) { + this.lockedBy = lockedBy; + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenReleaseDTO.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenReleaseDTO.java new file mode 100644 index 0000000000000000000000000000000000000000..99befb6c179d1e1a2620eb33ed0d4a33f16a1ae1 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/dto/OpenReleaseDTO.java @@ -0,0 +1,68 @@ +package com.ctrip.framework.apollo.openapi.dto; + +import com.ctrip.framework.apollo.common.dto.BaseDTO; + +import java.util.Map; + +public class OpenReleaseDTO extends BaseDTO { + + private String appId; + + private String clusterName; + + private String namespaceName; + + private String name; + + private Map configurations; + + private String comment; + + 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; + } + + public String getClusterName() { + return clusterName; + } + + public void setClusterName(String clusterName) { + this.clusterName = clusterName; + } + + public String getNamespaceName() { + return namespaceName; + } + + public void setNamespaceName(String namespaceName) { + this.namespaceName = namespaceName; + } + + public Map getConfigurations() { + return configurations; + } + + public void setConfigurations(Map configurations) { + this.configurations = configurations; + } + + public String getComment() { + return comment; + } + + public void setComment(String comment) { + this.comment = comment; + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/entity/Consumer.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/entity/Consumer.java new file mode 100644 index 0000000000000000000000000000000000000000..79e5e5488d9b7cdff4dfcbd8db75f2995b19ae29 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/entity/Consumer.java @@ -0,0 +1,92 @@ +package com.ctrip.framework.apollo.openapi.entity; + +import com.ctrip.framework.apollo.common.entity.BaseEntity; + +import org.hibernate.annotations.SQLDelete; +import org.hibernate.annotations.Where; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Table; + +@Entity +@Table(name = "Consumer") +@SQLDelete(sql = "Update Consumer set isDeleted = 1 where id = ?") +@Where(clause = "isDeleted = 0") +public class Consumer extends BaseEntity { + + @Column(name = "Name", nullable = false) + private String name; + + @Column(name = "AppId", nullable = false) + private String appId; + + @Column(name = "OrgId", nullable = false) + private String orgId; + + @Column(name = "OrgName", nullable = false) + private String orgName; + + @Column(name = "OwnerName", nullable = false) + private String ownerName; + + @Column(name = "OwnerEmail", nullable = false) + private String ownerEmail; + + public String getAppId() { + return appId; + } + + public String getName() { + return name; + } + + public String getOrgId() { + return orgId; + } + + public String getOrgName() { + return orgName; + } + + public String getOwnerEmail() { + return ownerEmail; + } + + public String getOwnerName() { + return ownerName; + } + + public void setAppId(String appId) { + this.appId = appId; + } + + public void setName(String name) { + this.name = name; + } + + public void setOrgId(String orgId) { + this.orgId = orgId; + } + + public void setOrgName(String orgName) { + this.orgName = orgName; + } + + public void setOwnerEmail(String ownerEmail) { + this.ownerEmail = ownerEmail; + } + + public void setOwnerName(String ownerName) { + this.ownerName = ownerName; + } + + @Override + public String toString() { + return toStringHelper().add("name", name).add("appId", appId) + .add("orgId", orgId) + .add("orgName", orgName) + .add("ownerName", ownerName) + .add("ownerEmail", ownerEmail).toString(); + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/entity/ConsumerRole.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/entity/ConsumerRole.java new file mode 100644 index 0000000000000000000000000000000000000000..fae234187861094d515d6a7d361d6f1c5dbfd7e4 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/entity/ConsumerRole.java @@ -0,0 +1,46 @@ +package com.ctrip.framework.apollo.openapi.entity; + +import com.ctrip.framework.apollo.common.entity.BaseEntity; + +import org.hibernate.annotations.SQLDelete; +import org.hibernate.annotations.Where; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Table; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@Entity +@Table(name = "ConsumerRole") +@SQLDelete(sql = "Update ConsumerRole set isDeleted = 1 where id = ?") +@Where(clause = "isDeleted = 0") +public class ConsumerRole extends BaseEntity { + @Column(name = "ConsumerId", nullable = false) + private long consumerId; + + @Column(name = "RoleId", nullable = false) + private long roleId; + + public long getConsumerId() { + return consumerId; + } + + public void setConsumerId(long consumerId) { + this.consumerId = consumerId; + } + + public long getRoleId() { + return roleId; + } + + public void setRoleId(long roleId) { + this.roleId = roleId; + } + + @Override + public String toString() { + return toStringHelper().add("consumerId", consumerId).add("roleId", roleId).toString(); + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/entity/ConsumerToken.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/entity/ConsumerToken.java new file mode 100644 index 0000000000000000000000000000000000000000..c3ac59e27d337f096b33062525e9147add252a3f --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/entity/ConsumerToken.java @@ -0,0 +1,60 @@ +package com.ctrip.framework.apollo.openapi.entity; + +import com.ctrip.framework.apollo.common.entity.BaseEntity; + +import org.hibernate.annotations.SQLDelete; +import org.hibernate.annotations.Where; + +import java.util.Date; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Table; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@Entity +@Table(name = "ConsumerToken") +@SQLDelete(sql = "Update ConsumerToken set isDeleted = 1 where id = ?") +@Where(clause = "isDeleted = 0") +public class ConsumerToken extends BaseEntity { + @Column(name = "ConsumerId", nullable = false) + private long consumerId; + + @Column(name = "token", nullable = false) + private String token; + + @Column(name = "Expires", nullable = false) + private Date expires; + + public long getConsumerId() { + return consumerId; + } + + public void setConsumerId(long consumerId) { + this.consumerId = consumerId; + } + + public String getToken() { + return token; + } + + public void setToken(String token) { + this.token = token; + } + + public Date getExpires() { + return expires; + } + + public void setExpires(Date expires) { + this.expires = expires; + } + + @Override + public String toString() { + return toStringHelper().add("consumerId", consumerId).add("token", token) + .add("expires", expires).toString(); + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/filter/ConsumerAuthenticationFilter.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/filter/ConsumerAuthenticationFilter.java new file mode 100644 index 0000000000000000000000000000000000000000..3b94a29963e717ce0819a012aa645a7fafe736eb --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/filter/ConsumerAuthenticationFilter.java @@ -0,0 +1,55 @@ +package com.ctrip.framework.apollo.openapi.filter; + +import com.ctrip.framework.apollo.openapi.util.ConsumerAuthUtil; + +import java.io.IOException; + +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletException; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +public class ConsumerAuthenticationFilter implements Filter { + private ConsumerAuthUtil consumerAuthUtil; + + public ConsumerAuthenticationFilter(ConsumerAuthUtil consumerAuthUtil) { + this.consumerAuthUtil = consumerAuthUtil; + } + + @Override + public void init(FilterConfig filterConfig) throws ServletException { + //nothing + } + + @Override + public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws + IOException, ServletException { + HttpServletRequest request = (HttpServletRequest) req; + HttpServletResponse response = (HttpServletResponse) resp; + + String token = request.getHeader("Authorization"); + + Long consumerId = consumerAuthUtil.getConsumerId(token); + + if (consumerId == null) { + response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized"); + return; + } + + consumerAuthUtil.storeConsumerId(request, consumerId); + + chain.doFilter(req, resp); + } + + @Override + public void destroy() { + //nothing + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/repository/ConsumerRepository.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/repository/ConsumerRepository.java new file mode 100644 index 0000000000000000000000000000000000000000..d87764303575759a8e25e4ef744259a8d876af42 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/repository/ConsumerRepository.java @@ -0,0 +1,11 @@ +package com.ctrip.framework.apollo.openapi.repository; + +import com.ctrip.framework.apollo.openapi.entity.Consumer; + +import org.springframework.data.repository.PagingAndSortingRepository; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +public interface ConsumerRepository extends PagingAndSortingRepository { +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/repository/ConsumerRoleRepository.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/repository/ConsumerRoleRepository.java new file mode 100644 index 0000000000000000000000000000000000000000..0e75f0414f0934c193502661f76f0fd04ff4a789 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/repository/ConsumerRoleRepository.java @@ -0,0 +1,24 @@ +package com.ctrip.framework.apollo.openapi.repository; + +import com.ctrip.framework.apollo.openapi.entity.ConsumerRole; + +import org.springframework.data.repository.PagingAndSortingRepository; + +import java.util.List; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +public interface ConsumerRoleRepository extends PagingAndSortingRepository { + /** + * find consumer roles by userId + * + * @param consumerId consumer id + */ + List findByConsumerId(long consumerId); + + /** + * find consumer roles by roleId + */ + List findByRoleId(long roleId); +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/repository/ConsumerTokenRepository.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/repository/ConsumerTokenRepository.java new file mode 100644 index 0000000000000000000000000000000000000000..ab78f7cf66720e3adb49b31e4f3a7cdb5b6844a1 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/repository/ConsumerTokenRepository.java @@ -0,0 +1,20 @@ +package com.ctrip.framework.apollo.openapi.repository; + +import com.ctrip.framework.apollo.openapi.entity.ConsumerToken; + +import org.springframework.data.repository.PagingAndSortingRepository; + +import java.util.Date; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +public interface ConsumerTokenRepository extends PagingAndSortingRepository { + /** + * find consumer token by token + * + * @param token the token + * @param validDate the date when the token is valid + */ + ConsumerToken findTopByTokenAndExpiresAfter(String token, Date validDate); +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/service/ConsumerRolePermissionService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/service/ConsumerRolePermissionService.java new file mode 100644 index 0000000000000000000000000000000000000000..805a6d8722875cc048a26d5c0bd110cf9e1f2178 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/service/ConsumerRolePermissionService.java @@ -0,0 +1,62 @@ +package com.ctrip.framework.apollo.openapi.service; + +import com.google.common.collect.FluentIterable; + +import com.ctrip.framework.apollo.openapi.entity.ConsumerRole; +import com.ctrip.framework.apollo.openapi.repository.ConsumerRoleRepository; +import com.ctrip.framework.apollo.portal.entity.po.Permission; +import com.ctrip.framework.apollo.portal.entity.po.RolePermission; +import com.ctrip.framework.apollo.portal.repository.PermissionRepository; +import com.ctrip.framework.apollo.portal.repository.RolePermissionRepository; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; + +import java.util.List; +import java.util.Set; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@Service +public class ConsumerRolePermissionService { + @Autowired + private PermissionRepository permissionRepository; + @Autowired + private ConsumerRoleRepository consumerRoleRepository; + @Autowired + private RolePermissionRepository rolePermissionRepository; + + /** + * Check whether user has the permission + */ + public boolean consumerHasPermission(long consumerId, String permissionType, String targetId) { + Permission permission = + permissionRepository.findTopByPermissionTypeAndTargetId(permissionType, targetId); + if (permission == null) { + return false; + } + + List consumerRoles = consumerRoleRepository.findByConsumerId(consumerId); + if (CollectionUtils.isEmpty(consumerRoles)) { + return false; + } + + Set roleIds = + FluentIterable.from(consumerRoles).transform(consumerRole -> consumerRole.getRoleId()) + .toSet(); + List rolePermissions = rolePermissionRepository.findByRoleIdIn(roleIds); + if (CollectionUtils.isEmpty(rolePermissions)) { + return false; + } + + for (RolePermission rolePermission : rolePermissions) { + if (rolePermission.getPermissionId() == permission.getId()) { + return true; + } + } + + return false; + } +} 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 new file mode 100644 index 0000000000000000000000000000000000000000..22dead92606a8c361c55e24c9481e753e8d2ab24 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/service/ConsumerService.java @@ -0,0 +1,84 @@ +package com.ctrip.framework.apollo.openapi.service; + +import com.google.common.base.Charsets; +import com.google.common.base.Joiner; +import com.google.common.base.Preconditions; +import com.google.common.base.Strings; +import com.google.common.hash.Hashing; + +import com.ctrip.framework.apollo.openapi.entity.Consumer; +import com.ctrip.framework.apollo.openapi.entity.ConsumerToken; +import com.ctrip.framework.apollo.openapi.repository.ConsumerRepository; +import com.ctrip.framework.apollo.openapi.repository.ConsumerTokenRepository; +import com.ctrip.framework.apollo.portal.service.ServerConfigService; + +import org.apache.commons.lang.time.FastDateFormat; +import org.springframework.beans.factory.InitializingBean; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.Date; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@Service +public class ConsumerService implements InitializingBean { + static final String TOKEN_SALT_KEY = "consumer.token.salt"; + private static final FastDateFormat TIMESTAMP_FORMAT = FastDateFormat.getInstance + ("yyyyMMddHHmmss"); + private static final Joiner KEY_JOINER = Joiner.on("|"); + @Autowired + private ConsumerTokenRepository consumerTokenRepository; + @Autowired + private ConsumerRepository consumerRepository; + @Autowired + private ServerConfigService serverConfigService; + + private String consumerTokenSalt; + + public Long getConsumerIdByToken(String token) { + if (Strings.isNullOrEmpty(token)) { + return null; + } + ConsumerToken consumerToken = consumerTokenRepository.findTopByTokenAndExpiresAfter(token, + new Date()); + return consumerToken == null ? null : consumerToken.getConsumerId(); + } + + public Consumer getConsumerByConsumerId(long consumerId) { + return consumerRepository.findOne(consumerId); + } + + public void generateAndEnrichConsumerToken(ConsumerToken consumerToken) { + Consumer consumer = getConsumerByConsumerId(consumerToken.getConsumerId()); + + Preconditions.checkState(consumer != null, String.format("Consumer with id: %d not found!", + consumerToken.getConsumerId())); + + if (consumerToken.getDataChangeCreatedTime() == null) { + consumerToken.setDataChangeCreatedTime(new Date()); + } + consumerToken.setToken(generateConsumerToken(consumer.getAppId(), consumerToken + .getDataChangeCreatedTime(), consumerTokenSalt)); + } + + @Transactional + public ConsumerToken createConsumerToken(ConsumerToken entity) { + entity.setId(0); //for protection + + return consumerTokenRepository.save(entity); + } + + String generateConsumerToken(String consumerAppId, Date generationTime, String + consumerTokenSalt) { + return Hashing.sha1().hashString(KEY_JOINER.join(consumerAppId, TIMESTAMP_FORMAT.format + (generationTime), consumerTokenSalt), Charsets.UTF_8).toString(); + } + + @Override + public void afterPropertiesSet() throws Exception { + consumerTokenSalt = serverConfigService.getValue(TOKEN_SALT_KEY, "apollo-portal"); + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/util/ConsumerAuthUtil.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/util/ConsumerAuthUtil.java new file mode 100644 index 0000000000000000000000000000000000000000..2507d52642a7358f43372daa732639795adf7c2f --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/util/ConsumerAuthUtil.java @@ -0,0 +1,36 @@ +package com.ctrip.framework.apollo.openapi.util; + +import com.ctrip.framework.apollo.openapi.service.ConsumerService; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import javax.servlet.http.HttpServletRequest; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@Service +public class ConsumerAuthUtil { + static final String CONSUMER_ID = "ApolloConsumerId"; + @Autowired + private ConsumerService consumerService; + + public Long getConsumerId(String token) { + return consumerService.getConsumerIdByToken(token); + } + + public void storeConsumerId(HttpServletRequest request, Long consumerId) { + request.setAttribute(CONSUMER_ID, consumerId); + } + + public long retrieveConsumerId(HttpServletRequest request) { + Object value = request.getAttribute(CONSUMER_ID); + + try { + return Long.parseLong(value.toString()); + } catch (Throwable ex) { + throw new IllegalStateException("No consumer id!", ex); + } + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/util/OpenApiBeanUtils.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/util/OpenApiBeanUtils.java new file mode 100644 index 0000000000000000000000000000000000000000..5ddc4af2da6949969f8c2c2aa70814fd98c86cc0 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/util/OpenApiBeanUtils.java @@ -0,0 +1,107 @@ +package com.ctrip.framework.apollo.openapi.util; + +import com.google.common.base.Preconditions; +import com.google.common.reflect.TypeToken; +import com.google.gson.Gson; + +import com.ctrip.framework.apollo.common.dto.ItemDTO; +import com.ctrip.framework.apollo.common.dto.NamespaceLockDTO; +import com.ctrip.framework.apollo.common.dto.ReleaseDTO; +import com.ctrip.framework.apollo.common.utils.BeanUtils; +import com.ctrip.framework.apollo.openapi.dto.OpenItemDTO; +import com.ctrip.framework.apollo.openapi.dto.OpenNamespaceDTO; +import com.ctrip.framework.apollo.openapi.dto.OpenNamespaceLockDTO; +import com.ctrip.framework.apollo.openapi.dto.OpenReleaseDTO; +import com.ctrip.framework.apollo.portal.entity.vo.NamespaceVO; + +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.stream.Collectors; + +public class OpenApiBeanUtils { + + private static Gson gson = new Gson(); + private static Type type = new TypeToken>() { + }.getType(); + + public static OpenItemDTO transformFromItemDTO(ItemDTO item) { + Preconditions.checkArgument(item != null); + return BeanUtils.transfrom(OpenItemDTO.class, item); + } + + public static ItemDTO transformToItemDTO(OpenItemDTO openItemDTO) { + Preconditions.checkArgument(openItemDTO != null); + return BeanUtils.transfrom(ItemDTO.class, openItemDTO); + } + + + public static OpenReleaseDTO transformFromReleaseDTO(ReleaseDTO release) { + Preconditions.checkArgument(release != null); + + OpenReleaseDTO openReleaseDTO = BeanUtils.transfrom(OpenReleaseDTO.class, release); + + Map configs = gson.fromJson(release.getConfigurations(), type); + + openReleaseDTO.setConfigurations(configs); + return openReleaseDTO; + } + + public static OpenNamespaceDTO transformFromNamespaceVO(NamespaceVO namespaceVO) { + Preconditions.checkArgument(namespaceVO != null); + + OpenNamespaceDTO openNamespaceDTO = BeanUtils.transfrom(OpenNamespaceDTO.class, namespaceVO + .getBaseInfo()); + + //app namespace info + openNamespaceDTO.setFormat(namespaceVO.getFormat()); + openNamespaceDTO.setComment(namespaceVO.getComment()); + openNamespaceDTO.setPublic(namespaceVO.isPublic()); + + //items + List items = new LinkedList<>(); + List itemVOs = namespaceVO.getItems(); + if (!CollectionUtils.isEmpty(itemVOs)) { + items.addAll(itemVOs.stream().map(itemVO -> transformFromItemDTO(itemVO.getItem())).collect + (Collectors.toList())); + } + openNamespaceDTO.setItems(items); + return openNamespaceDTO; + + } + + public static List batchTransformFromNamespaceVOs(List + namespaceVOs) { + if (CollectionUtils.isEmpty(namespaceVOs)) { + return Collections.emptyList(); + } + + List openNamespaceDTOs = + namespaceVOs.stream().map(OpenApiBeanUtils::transformFromNamespaceVO) + .collect(Collectors.toCollection(LinkedList::new)); + + return openNamespaceDTOs; + } + + public static OpenNamespaceLockDTO transformFromNamespaceLockDTO(String namespaceName, + NamespaceLockDTO + namespaceLock) { + OpenNamespaceLockDTO lock = new OpenNamespaceLockDTO(); + + lock.setNamespaceName(namespaceName); + + if (namespaceLock == null) { + lock.setLocked(false); + } else { + lock.setLocked(true); + lock.setLockedBy(namespaceLock.getDataChangeCreatedBy()); + } + + return lock; + } + +} 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 new file mode 100644 index 0000000000000000000000000000000000000000..5fda72412f2770097b85f3eec87b5bb790908262 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ItemController.java @@ -0,0 +1,107 @@ +package com.ctrip.framework.apollo.openapi.v1.controller; + +import com.ctrip.framework.apollo.common.dto.ItemDTO; +import com.ctrip.framework.apollo.common.exception.BadRequestException; +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.OpenItemDTO; +import com.ctrip.framework.apollo.openapi.util.OpenApiBeanUtils; +import com.ctrip.framework.apollo.portal.service.ItemService; +import com.ctrip.framework.apollo.portal.service.UserService; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +import javax.servlet.http.HttpServletRequest; + + +@RestController("openapiItemController") +@RequestMapping("/openapi/v1/envs/{env}") +public class ItemController { + + @Autowired + private ItemService itemService; + @Autowired + private UserService userService; + + + @PreAuthorize(value = "@consumerPermissionValidator.hasModifyNamespacePermission(#request, #appId, #namespaceName)") + @RequestMapping(value = "/apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/items", method = RequestMethod.POST) + public OpenItemDTO createItem(@PathVariable String appId, @PathVariable String env, + @PathVariable String clusterName, @PathVariable String + namespaceName, + @RequestBody OpenItemDTO item, HttpServletRequest request) { + + RequestPrecondition.checkArguments( + !StringUtils.isContainEmpty(item.getKey(), item.getValue(), item.getDataChangeCreatedBy()), + "key,value,dataChangeCreatedBy 字段不能为空"); + + if (userService.findByUserId(item.getDataChangeCreatedBy()) == null) { + throw new BadRequestException("用户不存在."); + } + + ItemDTO toCreate = OpenApiBeanUtils.transformToItemDTO(item); + + //protect + toCreate.setLineNum(0); + toCreate.setId(0); + toCreate.setDataChangeLastModifiedBy(toCreate.getDataChangeCreatedBy()); + + ItemDTO createdItem = itemService.createItem(appId, Env.fromString(env), + clusterName, namespaceName, toCreate); + return OpenApiBeanUtils.transformFromItemDTO(createdItem); + } + + @PreAuthorize(value = "@consumerPermissionValidator.hasModifyNamespacePermission(#request, #appId, #namespaceName)") + @RequestMapping(value = "/apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/items/{itemId}", method = RequestMethod.PUT) + public void updateItem(@PathVariable String appId, @PathVariable String env, + @PathVariable String clusterName, @PathVariable String namespaceName, + @PathVariable long itemId, @RequestBody OpenItemDTO item, + HttpServletRequest request) { + + RequestPrecondition.checkArguments(item != null && item.getId() > 0 && itemId == item.getId(), + "item data error"); + RequestPrecondition.checkArguments( + !StringUtils.isContainEmpty(item.getKey(), item.getValue(), item + .getDataChangeLastModifiedBy()), + "key,value,dataChangeLastModifiedBy 字段不能为空"); + + if (userService.findByUserId(item.getDataChangeLastModifiedBy()) == null) { + throw new BadRequestException("用户不存在."); + } + + ItemDTO toUpdateItem = itemService.loadItem(Env.fromString(env), itemId); + if (toUpdateItem == null) { + throw new BadRequestException("item not exist"); + } + //protect. only value,comment,lastModifiedBy can be modified + toUpdateItem.setComment(item.getComment()); + toUpdateItem.setValue(item.getValue()); + toUpdateItem.setDataChangeLastModifiedBy(item.getDataChangeLastModifiedBy()); + + itemService.updateItem(appId, Env.fromString(env), clusterName, namespaceName, + toUpdateItem); + } + + + @PreAuthorize(value = "@consumerPermissionValidator.hasModifyNamespacePermission(#request, #appId, #namespaceName)") + @RequestMapping(value = "/apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/items/{itemId}", method = RequestMethod.DELETE) + public void deleteItem(@PathVariable String appId, @PathVariable String env, + @PathVariable String clusterName, @PathVariable String namespaceName, + @PathVariable long itemId, @RequestParam String operator, + HttpServletRequest request) { + + if (userService.findByUserId(operator) == null) { + throw new BadRequestException("用户不存在."); + } + itemService.deleteItem(Env.fromString(env), itemId, operator); + } + +} 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 new file mode 100644 index 0000000000000000000000000000000000000000..e823bbf63325a03c4d22b51da1ec43c8ffdabf3c --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/NamespaceController.java @@ -0,0 +1,64 @@ +package com.ctrip.framework.apollo.openapi.v1.controller; + + +import com.ctrip.framework.apollo.common.dto.NamespaceDTO; +import com.ctrip.framework.apollo.common.dto.NamespaceLockDTO; +import com.ctrip.framework.apollo.core.enums.Env; +import com.ctrip.framework.apollo.openapi.dto.OpenNamespaceDTO; +import com.ctrip.framework.apollo.openapi.dto.OpenNamespaceLockDTO; +import com.ctrip.framework.apollo.openapi.util.OpenApiBeanUtils; +import com.ctrip.framework.apollo.portal.entity.vo.NamespaceVO; +import com.ctrip.framework.apollo.portal.service.NamespaceLockService; +import com.ctrip.framework.apollo.portal.service.NamespaceService; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@RestController("openapiNamespaceController") +@RequestMapping("/openapi/v1/envs/{env}") +public class NamespaceController { + + @Autowired + private NamespaceLockService namespaceLockService; + @Autowired + private NamespaceService namespaceService; + + @RequestMapping(value = "/apps/{appId}/clusters/{clusterName}/namespaces", method = RequestMethod.GET) + public List findNamespaces(@PathVariable String appId, @PathVariable String env, + @PathVariable String clusterName) { + + return OpenApiBeanUtils + .batchTransformFromNamespaceVOs(namespaceService.findNamespaces(appId, Env + .fromString(env), clusterName)); + } + + @RequestMapping(value = "/apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName:.+}", method = RequestMethod.GET) + public OpenNamespaceDTO loadNamespace(@PathVariable String appId, @PathVariable String env, + @PathVariable String clusterName, @PathVariable String + namespaceName) { + NamespaceVO namespaceVO = namespaceService.loadNamespace(appId, Env.fromString + (env), clusterName, namespaceName); + if (namespaceVO == null) { + return null; + } + return OpenApiBeanUtils.transformFromNamespaceVO(namespaceVO); + } + + @RequestMapping(value = "/apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/lock", method = RequestMethod.GET) + public OpenNamespaceLockDTO getNamespaceLock(@PathVariable String appId, @PathVariable String env, + @PathVariable String clusterName, @PathVariable + String namespaceName) { + + NamespaceDTO namespace = namespaceService.loadNamespaceBaseInfo(appId, Env + .fromString(env), clusterName, namespaceName); + NamespaceLockDTO lockDTO = namespaceLockService.getNamespaceLock(appId, Env + .fromString(env), clusterName, namespaceName); + return OpenApiBeanUtils.transformFromNamespaceLockDTO(namespace.getNamespaceName(), lockDTO); + } + +} 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 new file mode 100644 index 0000000000000000000000000000000000000000..867be0ac5eb1167f3ff370a1456666dc76fbc2a7 --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/openapi/v1/controller/ReleaseController.java @@ -0,0 +1,74 @@ +package com.ctrip.framework.apollo.openapi.v1.controller; + + +import com.ctrip.framework.apollo.common.dto.ReleaseDTO; +import com.ctrip.framework.apollo.common.exception.BadRequestException; +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.OpenReleaseDTO; +import com.ctrip.framework.apollo.openapi.util.OpenApiBeanUtils; +import com.ctrip.framework.apollo.portal.entity.form.NamespaceReleaseModel; +import com.ctrip.framework.apollo.portal.service.ReleaseService; +import com.ctrip.framework.apollo.portal.service.UserService; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RestController; + +import javax.servlet.http.HttpServletRequest; + +import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkModel; + +@RestController("openapiReleaseController") +@RequestMapping("/openapi/v1/envs/{env}") +public class ReleaseController { + + @Autowired + private ReleaseService releaseService; + @Autowired + private UserService userService; + + @PreAuthorize(value = "@consumerPermissionValidator.hasReleaseNamespacePermission(#request, #appId, #namespaceName)") + @RequestMapping(value = "/apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/releases", method = RequestMethod.POST) + public OpenReleaseDTO createRelease(@PathVariable String appId, @PathVariable String env, + @PathVariable String clusterName, @PathVariable String + namespaceName, + @RequestBody NamespaceReleaseModel model, + HttpServletRequest request) { + + checkModel(model != null); + RequestPrecondition.checkArguments(!StringUtils.isContainEmpty(model.getReleasedBy(), model + .getReleaseTitle()), + "releaseTitle and releaseBy can not be empty"); + + if (userService.findByUserId(model.getReleasedBy()) == null) { + throw new BadRequestException("用户不存在."); + } + + model.setAppId(appId); + model.setEnv(Env.fromString(env).toString()); + model.setClusterName(clusterName); + model.setNamespaceName(namespaceName); + + return OpenApiBeanUtils.transformFromReleaseDTO(releaseService.createRelease(model)); + } + + @RequestMapping(value = "/apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/releases/latest", method = RequestMethod.GET) + public OpenReleaseDTO loadLatestActiveRelease(@PathVariable String appId, @PathVariable String env, + @PathVariable String clusterName, @PathVariable + String namespaceName) { + ReleaseDTO releaseDTO = releaseService.loadLatestRelease(appId, Env.fromString + (env), clusterName, namespaceName); + if (releaseDTO == null) { + return null; + } + + return OpenApiBeanUtils.transformFromReleaseDTO(releaseDTO); + } + +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/PortalSettings.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/PortalSettings.java index 1c05bcbf7d326d37df0be2174f24cc4ab091ff23..da55a6b4845876e8ed86c0dd69bce01e87ea3be8 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/PortalSettings.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/PortalSettings.java @@ -1,7 +1,6 @@ package com.ctrip.framework.apollo.portal; - import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.portal.api.AdminServiceAPI; import com.ctrip.framework.apollo.portal.service.ServerConfigService; @@ -67,11 +66,11 @@ public class PortalSettings { healthCheckService .scheduleWithFixedDelay(new HealthCheckTask(applicationContext), 1000, HEALTH_CHECK_INTERVAL, - TimeUnit.MILLISECONDS); + TimeUnit.MILLISECONDS); } - public List getAllEnvs(){ + public List getAllEnvs() { return allEnvs; } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/AdminServiceAPI.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/AdminServiceAPI.java index b10e1929b59f572eb86d6b6c20f3c8fc921fcbb8..9b05f8d127c50370db0c6a0c5202902bb5abfe7d 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/AdminServiceAPI.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/AdminServiceAPI.java @@ -1,16 +1,16 @@ package com.ctrip.framework.apollo.portal.api; -import com.ctrip.framework.apollo.common.dto.AppNamespaceDTO; -import com.ctrip.framework.apollo.common.dto.CommitDTO; -import com.ctrip.framework.apollo.common.dto.NamespaceLockDTO; -import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.common.dto.AppDTO; +import com.ctrip.framework.apollo.common.dto.AppNamespaceDTO; import com.ctrip.framework.apollo.common.dto.ClusterDTO; +import com.ctrip.framework.apollo.common.dto.CommitDTO; import com.ctrip.framework.apollo.common.dto.ItemChangeSets; import com.ctrip.framework.apollo.common.dto.ItemDTO; import com.ctrip.framework.apollo.common.dto.NamespaceDTO; +import com.ctrip.framework.apollo.common.dto.NamespaceLockDTO; import com.ctrip.framework.apollo.common.dto.ReleaseDTO; +import com.ctrip.framework.apollo.core.enums.Env; import org.springframework.boot.actuate.health.Health; import org.springframework.http.HttpEntity; @@ -53,8 +53,8 @@ public class AdminServiceAPI { public List findNamespaceByCluster(String appId, Env env, String clusterName) { NamespaceDTO[] namespaceDTOs = restTemplate.get(env, "apps/{appId}/clusters/{clusterName}/namespaces", - NamespaceDTO[].class, appId, - clusterName); + NamespaceDTO[].class, appId, + clusterName); return Arrays.asList(namespaceDTOs); } @@ -62,7 +62,7 @@ public class AdminServiceAPI { String namespaceName) { NamespaceDTO dto = restTemplate.get(env, "apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}", - NamespaceDTO.class, appId, clusterName, namespaceName); + NamespaceDTO.class, appId, clusterName, namespaceName); return dto; } @@ -70,7 +70,7 @@ public class AdminServiceAPI { public NamespaceDTO createNamespace(Env env, NamespaceDTO namespace) { return restTemplate .post(env, "apps/{appId}/clusters/{clusterName}/namespaces", namespace, NamespaceDTO.class, - namespace.getAppId(), namespace.getClusterName()); + namespace.getAppId(), namespace.getClusterName()); } public AppNamespaceDTO createAppNamespace(Env env, AppNamespaceDTO appNamespace) { @@ -86,26 +86,29 @@ public class AdminServiceAPI { public List findItems(String appId, Env env, String clusterName, String namespaceName) { ItemDTO[] itemDTOs = restTemplate.get(env, "apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/items", - ItemDTO[].class, appId, clusterName, namespaceName); + ItemDTO[].class, appId, clusterName, namespaceName); return Arrays.asList(itemDTOs); } + public ItemDTO loadItem(Env env, long itemId) { + return restTemplate.get(env, "/items/{itemId}", ItemDTO.class, itemId); + } + public void updateItemsByChangeSet(String appId, Env env, String clusterName, String namespace, ItemChangeSets changeSets) { restTemplate.post(env, "apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/itemset", - changeSets, Void.class, appId, clusterName, namespace); + changeSets, Void.class, appId, clusterName, namespace); } public void updateItem(String appId, Env env, String clusterName, String namespace, long itemId, ItemDTO item) { restTemplate.put(env, "apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/items/{itemId}", - item, appId, clusterName, namespace, itemId); + item, appId, clusterName, namespace, itemId); } public ItemDTO createItem(String appId, Env env, String clusterName, String namespace, ItemDTO item) { return restTemplate.post(env, "apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/items", - item, ItemDTO.class, appId, clusterName, namespace) - ; + item, ItemDTO.class, appId, clusterName, namespace); } public void deleteItem(Env env, long itemId, String operator) { @@ -119,25 +122,25 @@ public class AdminServiceAPI { public List findClustersByApp(String appId, Env env) { ClusterDTO[] clusterDTOs = restTemplate.get(env, "apps/{appId}/clusters", ClusterDTO[].class, - appId); + appId); return Arrays.asList(clusterDTOs); } public ClusterDTO loadCluster(String appId, Env env, String clusterName) { return restTemplate.get(env, "apps/{appId}/clusters/{clusterName}", ClusterDTO.class, - appId, clusterName); + appId, clusterName); } public boolean isClusterUnique(String appId, Env env, String clusterName) { return restTemplate .get(env, "apps/{appId}/cluster/{clusterName}/unique", Boolean.class, - appId, clusterName); + appId, clusterName); } public ClusterDTO create(Env env, ClusterDTO cluster) { return restTemplate.post(env, "apps/{appId}/clusters", cluster, ClusterDTO.class, - cluster.getAppId()); + cluster.getAppId()); } } @@ -171,7 +174,7 @@ public class AdminServiceAPI { String namespace) { ReleaseDTO releaseDTO = restTemplate .get(env, "apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/releases/latest", - ReleaseDTO.class, appId, clusterName, namespace); + ReleaseDTO.class, appId, clusterName, namespace); return releaseDTO; } @@ -194,8 +197,8 @@ public class AdminServiceAPI { public void rollback(Env env, long releaseId, String operator) { restTemplate.put(env, - "releases/{releaseId}/rollback?operator={operator}", - null, releaseId, operator); + "releases/{releaseId}/rollback?operator={operator}", + null, releaseId, operator); } } @@ -205,9 +208,9 @@ public class AdminServiceAPI { public List find(String appId, Env env, String clusterName, String namespaceName, int page, int size) { CommitDTO[] commitDTOs = restTemplate.get(env, - "apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/commit?page={page}&size={size}", - CommitDTO[].class, - appId, clusterName, namespaceName, page, size); + "apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/commit?page={page}&size={size}", + CommitDTO[].class, + appId, clusterName, namespaceName, page, size); return Arrays.asList(commitDTOs); } @@ -218,8 +221,8 @@ public class AdminServiceAPI { public NamespaceLockDTO getNamespaceLockOwner(String appId, Env env, String clusterName, String namespaceName) { return restTemplate.get(env, "apps/{appId}/clusters/{clusterName}/namespaces/{namespaceName}/lock", - NamespaceLockDTO.class, - appId, clusterName, namespaceName); + NamespaceLockDTO.class, + appId, clusterName, namespaceName); } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/AdminServiceAddressLocator.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/AdminServiceAddressLocator.java index ddc745ad4348ba056f512a37bd8a2b422b89b79a..4024651ae31f745e228b2678030ea4f752c482e8 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/AdminServiceAddressLocator.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/AdminServiceAddressLocator.java @@ -73,7 +73,7 @@ public class AdminServiceAddressLocator { public List getServiceList(Env env) { List services = cache.get(env); if (CollectionUtils.isEmpty(services)) { - return Collections.EMPTY_LIST; + return Collections.emptyList(); } List randomConfigServices = Lists.newArrayList(services); Collections.shuffle(randomConfigServices); @@ -81,7 +81,7 @@ public class AdminServiceAddressLocator { } //Maintain admin server address - class RefreshAdminServerAddressTask implements Runnable { + private class RefreshAdminServerAddressTask implements Runnable { @Override public void run() { diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/RetryableRestTemplate.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/RetryableRestTemplate.java index a0875a149de378f229a3caae50b24d89c77d244b..0ec407473aec9e40e1fe96fb7b7e7c4808e5412c 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/RetryableRestTemplate.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/api/RetryableRestTemplate.java @@ -1,8 +1,8 @@ package com.ctrip.framework.apollo.portal.api; +import com.ctrip.framework.apollo.common.exception.ServiceException; import com.ctrip.framework.apollo.core.dto.ServiceDTO; import com.ctrip.framework.apollo.core.enums.Env; -import com.ctrip.framework.apollo.common.exception.ServiceException; import com.ctrip.framework.apollo.portal.constant.CatEventType; import com.dianping.cat.Cat; import com.dianping.cat.message.Message; @@ -66,7 +66,7 @@ public class RetryableRestTemplate { private T execute(HttpMethod method, Env env, String path, Object request, Class responseType, Object... uriVariables) { - if (path.startsWith("/")){ + if (path.startsWith("/")) { path = path.substring(1, path.length()); } @@ -143,11 +143,11 @@ public class RetryableRestTemplate { Throwable nestedException = e.getCause(); if (method == HttpMethod.GET) { return nestedException instanceof SocketTimeoutException - || nestedException instanceof HttpHostConnectException - || nestedException instanceof ConnectTimeoutException; + || nestedException instanceof HttpHostConnectException + || nestedException instanceof ConnectTimeoutException; } else { return nestedException instanceof HttpHostConnectException - || nestedException instanceof ConnectTimeoutException; + || nestedException instanceof ConnectTimeoutException; } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/PermissionValidator.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/PermissionValidator.java index 163485b69375d7208f9a09720a94330207e9b35c..b44e2ab68db3f01ab9fbd4d4a15cb425f30026ec 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/PermissionValidator.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/PermissionValidator.java @@ -18,43 +18,47 @@ public class PermissionValidator { public boolean hasModifyNamespacePermission(String appId, String namespaceName) { return rolePermissionService.userHasPermission(userInfoHolder.getUser().getUserId(), - PermissionType.MODIFY_NAMESPACE, - RoleUtils.buildNamespaceTargetId(appId, namespaceName)); + PermissionType.MODIFY_NAMESPACE, + RoleUtils.buildNamespaceTargetId(appId, namespaceName)); } public boolean hasReleaseNamespacePermission(String appId, String namespaceName) { return rolePermissionService.userHasPermission(userInfoHolder.getUser().getUserId(), - PermissionType.RELEASE_NAMESPACE, - RoleUtils.buildNamespaceTargetId(appId, namespaceName)); + PermissionType.RELEASE_NAMESPACE, + RoleUtils.buildNamespaceTargetId(appId, namespaceName)); } public boolean hasAssignRolePermission(String appId) { return rolePermissionService.userHasPermission(userInfoHolder.getUser().getUserId(), - PermissionType.ASSIGN_ROLE, - appId); + PermissionType.ASSIGN_ROLE, + appId); } public boolean hasCreateNamespacePermission(String appId) { return rolePermissionService.userHasPermission(userInfoHolder.getUser().getUserId(), - PermissionType.CREATE_NAMESPACE, - appId); + PermissionType.CREATE_NAMESPACE, + appId); } public boolean hasCreateClusterPermission(String appId) { return rolePermissionService.userHasPermission(userInfoHolder.getUser().getUserId(), - PermissionType.CREATE_CLUSTER, - appId); + PermissionType.CREATE_CLUSTER, + appId); } public boolean hasCreateAppNamespacePermission(String appId, AppNamespace appNamespace) { boolean isPublicAppNamespace = appNamespace.isPublic(); - if (isPublicAppNamespace){ + if (isPublicAppNamespace) { return hasCreateNamespacePermission(appId); - }else { + } else { return rolePermissionService.isSuperAdmin(userInfoHolder.getUser().getUserId()); } } + + public boolean isSuperAdmin() { + return rolePermissionService.isSuperAdmin(userInfoHolder.getUser().getUserId()); + } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/ctrip/CtripUserService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/ctrip/CtripUserService.java index 481c682c210d163114c3ec14786798bbc7764851..b19caff963d577a6c55e700bccf3744c0406e971 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/ctrip/CtripUserService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/ctrip/CtripUserService.java @@ -14,7 +14,6 @@ import org.springframework.http.HttpMethod; import org.springframework.http.ResponseEntity; import org.springframework.http.client.ClientHttpRequestFactory; import org.springframework.http.client.SimpleClientHttpRequestFactory; -import org.springframework.http.converter.json.GsonHttpMessageConverter; import org.springframework.util.CollectionUtils; import org.springframework.web.client.RestTemplate; @@ -62,7 +61,7 @@ public class CtripUserService implements UserService { } @Override - public List searchUsers(String keyword, int offset, int limit) { + public List searchUsers(String keyword, int offset, int limit) { UserServiceRequest request = assembleSearchUserRequest(keyword, offset, limit); HttpEntity entity = new HttpEntity<>(request); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/defaultimpl/DefaultUserInfoHolder.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/defaultimpl/DefaultUserInfoHolder.java index 961a13fea32f0954671433248152db7ea225aa48..263f23133aab2b85a7b5feb2f2e4ea337ae2e9cc 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/defaultimpl/DefaultUserInfoHolder.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/defaultimpl/DefaultUserInfoHolder.java @@ -9,7 +9,7 @@ import com.ctrip.framework.apollo.portal.entity.po.UserInfo; public class DefaultUserInfoHolder implements UserInfoHolder { - public DefaultUserInfoHolder(){ + public DefaultUserInfoHolder() { } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/defaultimpl/DefaultUserService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/defaultimpl/DefaultUserService.java index 0c19e33b5c2d49ddaed24325ac4745db4913f529..647c6a98b227f5f0d6bfe6ea872a768cca9ae52e 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/defaultimpl/DefaultUserService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/auth/defaultimpl/DefaultUserService.java @@ -6,7 +6,6 @@ import com.ctrip.framework.apollo.portal.entity.po.UserInfo; import com.ctrip.framework.apollo.portal.service.UserService; import java.util.Arrays; -import java.util.Collections; import java.util.List; /** diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/configuration/AuthConfiguration.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/configuration/AuthConfiguration.java index 997456e60898598c64a70296a67e06c86855a995..2763bfd07692da76931f31225c92c37b75abe38d 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/configuration/AuthConfiguration.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/configuration/AuthConfiguration.java @@ -1,5 +1,12 @@ package com.ctrip.framework.apollo.portal.configuration; +import com.google.common.collect.Maps; + +import com.ctrip.framework.apollo.openapi.filter.ConsumerAuthenticationFilter; +import com.ctrip.framework.apollo.openapi.util.ConsumerAuthUtil; +import com.ctrip.framework.apollo.portal.auth.LogoutHandler; +import com.ctrip.framework.apollo.portal.auth.SsoHeartbeatHandler; +import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.auth.ctrip.CtripLogoutHandler; import com.ctrip.framework.apollo.portal.auth.ctrip.CtripSsoHeartbeatHandler; import com.ctrip.framework.apollo.portal.auth.ctrip.CtripUserInfoHolder; @@ -8,9 +15,6 @@ import com.ctrip.framework.apollo.portal.auth.defaultimpl.DefaultLogoutHandler; import com.ctrip.framework.apollo.portal.auth.defaultimpl.DefaultSsoHeartbeatHandler; import com.ctrip.framework.apollo.portal.auth.defaultimpl.DefaultUserInfoHolder; import com.ctrip.framework.apollo.portal.auth.defaultimpl.DefaultUserService; -import com.ctrip.framework.apollo.portal.auth.LogoutHandler; -import com.ctrip.framework.apollo.portal.auth.SsoHeartbeatHandler; -import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.service.ServerConfigService; import com.ctrip.framework.apollo.portal.service.UserService; @@ -23,7 +27,6 @@ import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Profile; import java.util.EventListener; -import java.util.HashMap; import java.util.Map; import javax.servlet.Filter; @@ -47,21 +50,21 @@ public class AuthConfiguration { private ServerConfigService serverConfigService; @Bean - public ServletListenerRegistrationBean redisAppSettingListner(){ + public ServletListenerRegistrationBean redisAppSettingListner() { ServletListenerRegistrationBean redisAppSettingListner = new ServletListenerRegistrationBean(); redisAppSettingListner.setListener(listener("org.jasig.cas.client.credis.CRedisAppSettingListner")); return redisAppSettingListner; } @Bean - public ServletListenerRegistrationBean singleSignOutHttpSessionListener(){ + public ServletListenerRegistrationBean singleSignOutHttpSessionListener() { ServletListenerRegistrationBean singleSignOutHttpSessionListener = new ServletListenerRegistrationBean(); singleSignOutHttpSessionListener.setListener(listener("org.jasig.cas.client.session.SingleSignOutHttpSessionListener")); return singleSignOutHttpSessionListener; } @Bean - public FilterRegistrationBean casFilter(){ + public FilterRegistrationBean casFilter() { FilterRegistrationBean singleSignOutFilter = new FilterRegistrationBean(); singleSignOutFilter.setFilter(filter("org.jasig.cas.client.session.SingleSignOutFilter")); singleSignOutFilter.addUrlPatterns("/*"); @@ -69,15 +72,16 @@ public class AuthConfiguration { } @Bean - public FilterRegistrationBean authenticationFilter(){ + public FilterRegistrationBean authenticationFilter() { FilterRegistrationBean casFilter = new FilterRegistrationBean(); - Map filterInitParam = new HashMap(); + Map filterInitParam = Maps.newHashMap(); filterInitParam.put("redisClusterName", "casClientPrincipal"); filterInitParam.put("serverName", serverConfigService.getValue("serverName")); filterInitParam.put("casServerLoginUrl", serverConfigService.getValue("casServerLoginUrl")); //we don't want to use session to store login information, since we will be deployed to a cluster, not a single instance filterInitParam.put("useSession", "false"); + filterInitParam.put("/openapi.*", "exclude"); casFilter.setInitParameters(filterInitParam); casFilter.setFilter(filter("com.ctrip.framework.apollo.sso.filter.ApolloAuthenticationFilter")); @@ -87,9 +91,9 @@ public class AuthConfiguration { } @Bean - public FilterRegistrationBean casValidationFilter(){ + public FilterRegistrationBean casValidationFilter() { FilterRegistrationBean casValidationFilter = new FilterRegistrationBean(); - Map filterInitParam = new HashMap(); + Map filterInitParam = Maps.newHashMap(); filterInitParam.put("casServerUrlPrefix", serverConfigService.getValue("casServerUrlPrefix")); filterInitParam.put("serverName", serverConfigService.getValue("serverName")); filterInitParam.put("encoding", "UTF-8"); @@ -107,11 +111,15 @@ public class AuthConfiguration { } - @Bean - public FilterRegistrationBean assertionHolder(){ + public FilterRegistrationBean assertionHolder() { FilterRegistrationBean assertionHolderFilter = new FilterRegistrationBean(); + Map filterInitParam = Maps.newHashMap(); + filterInitParam.put("/openapi.*", "exclude"); + + assertionHolderFilter.setInitParameters(filterInitParam); + assertionHolderFilter.setFilter(filter("com.ctrip.framework.apollo.sso.filter.ApolloAssertionThreadLocalFilter")); assertionHolderFilter.addUrlPatterns("/*"); @@ -119,16 +127,16 @@ public class AuthConfiguration { } @Bean - public CtripUserInfoHolder ctripUserInfoHolder(){ + public CtripUserInfoHolder ctripUserInfoHolder() { return new CtripUserInfoHolder(); } @Bean - public CtripLogoutHandler logoutHandler(){ + public CtripLogoutHandler logoutHandler() { return new CtripLogoutHandler(); } - private Filter filter(String className){ + private Filter filter(String className) { Class clazz = null; try { clazz = Class.forName(className); @@ -140,7 +148,7 @@ public class AuthConfiguration { } - private EventListener listener(String className){ + private EventListener listener(String className) { Class clazz = null; try { clazz = Class.forName(className); @@ -168,6 +176,16 @@ public class AuthConfiguration { @Configuration static class DefaultAuthAutoConfiguration { + @Bean + public FilterRegistrationBean openApiAuthenticationFilter(ConsumerAuthUtil consumerAuthUtil) { + FilterRegistrationBean openApiFilter = new FilterRegistrationBean(); + + openApiFilter.setFilter(new ConsumerAuthenticationFilter(consumerAuthUtil)); + openApiFilter.addUrlPatterns("/openapi/*"); + + return openApiFilter; + } + @Bean @ConditionalOnMissingBean(SsoHeartbeatHandler.class) public SsoHeartbeatHandler defaultSsoHeartbeatHandler() { @@ -176,13 +194,13 @@ public class AuthConfiguration { @Bean @ConditionalOnMissingBean(UserInfoHolder.class) - public DefaultUserInfoHolder notCtripUserInfoHolder(){ + public DefaultUserInfoHolder notCtripUserInfoHolder() { return new DefaultUserInfoHolder(); } @Bean @ConditionalOnMissingBean(LogoutHandler.class) - public DefaultLogoutHandler logoutHandler(){ + public DefaultLogoutHandler logoutHandler() { return new DefaultLogoutHandler(); } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/configuration/WebContextConfiguration.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/configuration/WebContextConfiguration.java index 3e75408e44c8d41f595d3207a6bb40addcc1f861..e5b1ad66e749572d9aaab0a1edb451c821019372 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/configuration/WebContextConfiguration.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/configuration/WebContextConfiguration.java @@ -36,11 +36,11 @@ public class WebContextConfiguration { String loggingServerPort = serverConfigService.getValue("loggingServerPort"); String credisServiceUrl = serverConfigService.getValue("credisServiceUrl"); servletContext.setInitParameter("loggingServerIP", - Strings.isNullOrEmpty(loggingServerIP) ? "" : loggingServerIP); + Strings.isNullOrEmpty(loggingServerIP) ? "" : loggingServerIP); servletContext.setInitParameter("loggingServerPort", - Strings.isNullOrEmpty(loggingServerPort) ? "" : loggingServerPort); + Strings.isNullOrEmpty(loggingServerPort) ? "" : loggingServerPort); servletContext.setInitParameter("credisServiceUrl", - Strings.isNullOrEmpty(credisServiceUrl) ? "" : credisServiceUrl); + Strings.isNullOrEmpty(credisServiceUrl) ? "" : credisServiceUrl); } }; } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/constant/PermissionType.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/constant/PermissionType.java index f8fb3166d8e67b494ead52def74de84d2b8e98e1..ecef8d83cd62aa38fa2421e99675adc838636feb 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/constant/PermissionType.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/constant/PermissionType.java @@ -2,7 +2,9 @@ package com.ctrip.framework.apollo.portal.constant; public interface PermissionType { - /** APP level permission */ + /** + * APP level permission + */ String CREATE_NAMESPACE = "CreateNamespace"; @@ -13,7 +15,9 @@ public interface PermissionType { */ String ASSIGN_ROLE = "AssignRole"; - /** namespace level permission*/ + /** + * namespace level permission + */ String MODIFY_NAMESPACE = "ModifyNamespace"; diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/AppController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/AppController.java index 68b25f6d108fdbe6bfad4f4acbd4456122192a83..619ce95c8ab51dc39d32281219bf073c53066bfc 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/AppController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/AppController.java @@ -2,11 +2,12 @@ package com.ctrip.framework.apollo.portal.controller; import com.ctrip.framework.apollo.common.entity.App; +import com.ctrip.framework.apollo.common.exception.BadRequestException; import com.ctrip.framework.apollo.common.http.MultiResponseEntity; import com.ctrip.framework.apollo.common.http.RichResponseEntity; 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.common.exception.BadRequestException; import com.ctrip.framework.apollo.portal.PortalSettings; import com.ctrip.framework.apollo.portal.entity.po.UserInfo; import com.ctrip.framework.apollo.portal.entity.vo.EnvClusterInfo; @@ -27,7 +28,6 @@ import org.springframework.web.client.HttpClientErrorException; import java.util.List; -import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkArgument; @RestController @RequestMapping("/apps") @@ -75,14 +75,14 @@ public class AppController { @RequestMapping(value = "", method = RequestMethod.POST) public ResponseEntity create(@RequestBody App app) { - checkArgument(app.getName(), app.getAppId(), app.getOwnerName(), + RequestPrecondition.checkArgumentsNotEmpty(app.getName(), app.getAppId(), app.getOwnerName(), app.getOrgId(), app.getOrgName()); if (!InputValidator.isValidClusterNamespace(app.getAppId())) { throw new BadRequestException(String.format("AppId格式错误: %s", InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE)); } UserInfo userInfo = userService.findByUserId(app.getOwnerName()); - if (userInfo == null){ + if (userInfo == null) { throw new BadRequestException("应用负责人不存在"); } app.setOwnerEmail(userInfo.getEmail()); @@ -98,7 +98,7 @@ public class AppController { "application/json"}) public ResponseEntity create(@PathVariable String env, @RequestBody App app) { - checkArgument(app.getName(), app.getAppId(), app.getOwnerEmail(), app.getOwnerName(), + RequestPrecondition.checkArgumentsNotEmpty(app.getName(), app.getAppId(), app.getOwnerEmail(), app.getOwnerName(), app.getOrgId(), app.getOrgName()); if (!InputValidator.isValidClusterNamespace(app.getAppId())) { throw new BadRequestException(InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ClusterController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ClusterController.java index 9e3f9f1a41b6d8e4065cd74163e2e24c252b7b64..dfd484012cbd119bbcd01709c5416511940b0547 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ClusterController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ClusterController.java @@ -1,9 +1,10 @@ package com.ctrip.framework.apollo.portal.controller; -import com.ctrip.framework.apollo.common.utils.InputValidator; import com.ctrip.framework.apollo.common.dto.ClusterDTO; -import com.ctrip.framework.apollo.core.enums.Env; 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.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.service.ClusterService; @@ -15,7 +16,6 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; -import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkArgument; import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkModel; @RestController @@ -29,10 +29,10 @@ public class ClusterController { @PreAuthorize(value = "@permissionValidator.hasCreateClusterPermission(#appId)") @RequestMapping(value = "apps/{appId}/envs/{env}/clusters", method = RequestMethod.POST) public ClusterDTO createCluster(@PathVariable String appId, @PathVariable String env, - @RequestBody ClusterDTO cluster){ + @RequestBody ClusterDTO cluster) { checkModel(cluster != null); - checkArgument(cluster.getAppId(), cluster.getName()); + RequestPrecondition.checkArgumentsNotEmpty(cluster.getAppId(), cluster.getName()); if (!InputValidator.isValidClusterNamespace(cluster.getName())) { throw new BadRequestException(String.format("Cluster格式错误: %s", InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE)); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/CommitController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/CommitController.java index 798653b7674f58031312327017155785fb0a66a8..76f67a108d771c729d567e5b702befd040b18d12 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/CommitController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/CommitController.java @@ -1,7 +1,7 @@ package com.ctrip.framework.apollo.portal.controller; -import com.ctrip.framework.apollo.common.utils.RequestPrecondition; import com.ctrip.framework.apollo.common.dto.CommitDTO; +import com.ctrip.framework.apollo.common.utils.RequestPrecondition; import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.portal.service.CommitService; @@ -23,7 +23,7 @@ public class CommitController { @RequestMapping(value = "/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/commits") public List find(@PathVariable String appId, @PathVariable String env, @PathVariable String clusterName, @PathVariable String namespaceName, - @RequestParam(defaultValue = "0") int page, @RequestParam(defaultValue = "10") int size){ + @RequestParam(defaultValue = "0") int page, @RequestParam(defaultValue = "10") int size) { RequestPrecondition.checkNumberPositive(size); RequestPrecondition.checkNumberNotNegative(page); 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 new file mode 100644 index 0000000000000000000000000000000000000000..4f2c88f4dc03006e283e7c6c2ec305fd8965d5ba --- /dev/null +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ConsumerController.java @@ -0,0 +1,65 @@ +package com.ctrip.framework.apollo.portal.controller; + +import com.ctrip.framework.apollo.openapi.entity.ConsumerToken; +import com.ctrip.framework.apollo.openapi.service.ConsumerService; +import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.format.annotation.DateTimeFormat; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +import java.util.Calendar; +import java.util.Date; +import java.util.GregorianCalendar; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@RestController +@RequestMapping("/consumers") +public class ConsumerController { + private static final Date DEFAULT_EXPIRES = new GregorianCalendar(2099, Calendar.JANUARY, 1) + .getTime(); + + @Autowired + private ConsumerService consumerService; + @Autowired + private UserInfoHolder userInfoHolder; + + @PreAuthorize(value = "@permissionValidator.isSuperAdmin()") + @RequestMapping(value = "/{consumerId}/tokens", method = RequestMethod.POST) + public ConsumerToken createConsumerToken(@PathVariable long consumerId, + @RequestParam(value = "expires", required = false) + @DateTimeFormat(pattern = "yyyyMMddHHmmss") Date + expires) { + if (expires == null) { + expires = DEFAULT_EXPIRES; + } + + ConsumerToken consumerToken = generateConsumerToken(consumerId, expires); + + return consumerService.createConsumerToken(consumerToken); + } + + private ConsumerToken generateConsumerToken(long consumerId, Date expires) { + String createdBy = userInfoHolder.getUser().getUserId(); + Date createdTime = new Date(); + + ConsumerToken consumerToken = new ConsumerToken(); + consumerToken.setConsumerId(consumerId); + consumerToken.setExpires(expires); + consumerToken.setDataChangeCreatedBy(createdBy); + consumerToken.setDataChangeCreatedTime(createdTime); + consumerToken.setDataChangeLastModifiedBy(createdBy); + consumerToken.setDataChangeLastModifiedTime(createdTime); + + consumerService.generateAndEnrichConsumerToken(consumerToken); + + return consumerToken; + } +} diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/EnvController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/EnvController.java index c7e3302fc71950da4dfaf43e942b2fcc8d541780..0e9dfb392431b1dbf8171fa8c2abbe112ee15a17 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/EnvController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/EnvController.java @@ -18,7 +18,7 @@ public class EnvController { private PortalSettings portalSettings; @RequestMapping(value = "", method = RequestMethod.GET) - public List envs(){ + public List envs() { return portalSettings.getActiveEnvs(); } 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 3dda0c662c799e32c8306e28f21558365e4f1215..bfc65e1b553d3ff2aa592e951ad60c1432275e85 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 @@ -1,13 +1,14 @@ package com.ctrip.framework.apollo.portal.controller; import com.ctrip.framework.apollo.common.dto.ItemDTO; -import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.common.exception.BadRequestException; +import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.core.utils.StringUtils; -import com.ctrip.framework.apollo.portal.entity.vo.ItemDiffs; +import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.entity.form.NamespaceSyncModel; import com.ctrip.framework.apollo.portal.entity.form.NamespaceTextModel; -import com.ctrip.framework.apollo.portal.service.ConfigService; +import com.ctrip.framework.apollo.portal.entity.vo.ItemDiffs; +import com.ctrip.framework.apollo.portal.service.ItemService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; @@ -29,14 +30,16 @@ import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkM public class ItemController { @Autowired - private ConfigService configService; + private ItemService configService; + @Autowired + private UserInfoHolder userInfoHolder; @PreAuthorize(value = "@permissionValidator.hasModifyNamespacePermission(#appId, #namespaceName)") @RequestMapping(value = "/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/items", method = RequestMethod.PUT, consumes = { "application/json"}) public void modifyItemsByText(@PathVariable String appId, @PathVariable String env, - @PathVariable String clusterName, @PathVariable String namespaceName, - @RequestBody NamespaceTextModel model) { + @PathVariable String clusterName, @PathVariable String namespaceName, + @RequestBody NamespaceTextModel model) { checkModel(model != null); @@ -52,7 +55,7 @@ public class ItemController { @RequestMapping(value = "/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/item", method = RequestMethod.POST) public ItemDTO createItem(@PathVariable String appId, @PathVariable String env, @PathVariable String clusterName, @PathVariable String namespaceName, - @RequestBody ItemDTO item){ + @RequestBody ItemDTO item) { checkModel(isValidItem(item)); return configService.createItem(appId, Env.valueOf(env), clusterName, namespaceName, item); @@ -61,8 +64,8 @@ public class ItemController { @PreAuthorize(value = "@permissionValidator.hasModifyNamespacePermission(#appId, #namespaceName)") @RequestMapping(value = "/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/item", method = RequestMethod.PUT) public void updateItem(@PathVariable String appId, @PathVariable String env, - @PathVariable String clusterName, @PathVariable String namespaceName, - @RequestBody ItemDTO item){ + @PathVariable String clusterName, @PathVariable String namespaceName, + @RequestBody ItemDTO item) { checkModel(isValidItem(item)); configService.updateItem(appId, Env.valueOf(env), clusterName, namespaceName, item); @@ -73,27 +76,26 @@ public class ItemController { @RequestMapping(value = "/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/items/{itemId}", method = RequestMethod.DELETE) public void deleteItem(@PathVariable String appId, @PathVariable String env, @PathVariable String clusterName, @PathVariable String namespaceName, - @PathVariable long itemId){ - if (itemId <= 0){ + @PathVariable long itemId) { + if (itemId <= 0) { throw new BadRequestException("item id invalid"); } - configService.deleteItem(Env.valueOf(env), itemId); + configService.deleteItem(Env.valueOf(env), itemId, userInfoHolder.getUser().getUserId()); } - @RequestMapping(value = "/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/items") public List findItems(@PathVariable String appId, @PathVariable String env, @PathVariable String clusterName, @PathVariable String namespaceName, - @RequestParam(defaultValue = "lineNum") String orderBy){ + @RequestParam(defaultValue = "lineNum") String orderBy) { List items = configService.findItems(appId, Env.valueOf(env), clusterName, namespaceName); - if ("lastModifiedTime".equals(orderBy)){ + if ("lastModifiedTime".equals(orderBy)) { Collections.sort(items, (o1, o2) -> { - if (o1.getDataChangeLastModifiedTime().after(o2.getDataChangeLastModifiedTime())){ + if (o1.getDataChangeLastModifiedTime().after(o2.getDataChangeLastModifiedTime())) { return -1; } - if (o1.getDataChangeLastModifiedTime().before(o2.getDataChangeLastModifiedTime())){ + if (o1.getDataChangeLastModifiedTime().before(o2.getDataChangeLastModifiedTime())) { return 1; } return 0; @@ -104,7 +106,7 @@ public class ItemController { @RequestMapping(value = "/namespaces/{namespaceName}/diff", method = RequestMethod.POST, consumes = { "application/json"}) - public List diff(@RequestBody NamespaceSyncModel model){ + public List diff(@RequestBody NamespaceSyncModel model) { checkModel(model != null && !model.isInvalid()); return configService.compare(model.getSyncToNamespaces(), model.getSyncItems()); @@ -114,14 +116,14 @@ public class ItemController { @RequestMapping(value = "/apps/{appId}/namespaces/{namespaceName}/items", method = RequestMethod.PUT, consumes = { "application/json"}) public ResponseEntity update(@PathVariable String appId, @PathVariable String namespaceName, - @RequestBody NamespaceSyncModel model){ + @RequestBody NamespaceSyncModel model) { checkModel(model != null && !model.isInvalid()); configService.syncItems(model.getSyncToNamespaces(), model.getSyncItems()); return ResponseEntity.status(HttpStatus.OK).build(); } - private boolean isValidItem(ItemDTO item){ + private boolean isValidItem(ItemDTO item) { return item != null && !StringUtils.isContainEmpty(item.getKey()); } 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 e476f573e8d981efe2801ba1b5403a5342cf42ea..b5acda50b3f764c0a489f3ebf21ae4681839315e 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 @@ -1,12 +1,13 @@ package com.ctrip.framework.apollo.portal.controller; +import com.ctrip.framework.apollo.common.dto.NamespaceDTO; import com.ctrip.framework.apollo.common.entity.App; import com.ctrip.framework.apollo.common.entity.AppNamespace; +import com.ctrip.framework.apollo.common.exception.BadRequestException; import com.ctrip.framework.apollo.common.utils.InputValidator; -import com.ctrip.framework.apollo.common.dto.NamespaceDTO; +import com.ctrip.framework.apollo.common.utils.RequestPrecondition; import com.ctrip.framework.apollo.core.enums.ConfigFileFormat; import com.ctrip.framework.apollo.core.enums.Env; -import com.ctrip.framework.apollo.common.exception.BadRequestException; import com.ctrip.framework.apollo.core.utils.StringUtils; import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.entity.form.NamespaceCreationModel; @@ -33,7 +34,6 @@ import org.springframework.web.bind.annotation.RestController; import java.util.List; -import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkArgument; import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkModel; @RestController @@ -71,7 +71,8 @@ public class NamespaceController { for (NamespaceCreationModel model : models) { NamespaceDTO namespace = model.getNamespace(); - checkArgument(model.getEnv(), namespace.getAppId(), namespace.getClusterName(), namespace.getNamespaceName()); + RequestPrecondition + .checkArgumentsNotEmpty(model.getEnv(), namespace.getAppId(), namespace.getClusterName(), namespace.getNamespaceName()); try { // TODO: 16/6/17 某些环境创建失败,统一处理这种场景 @@ -89,11 +90,11 @@ public class NamespaceController { @RequestMapping(value = "/apps/{appId}/appnamespaces", method = RequestMethod.POST) public AppNamespace createAppNamespace(@PathVariable String appId, @RequestBody AppNamespace appNamespace) { - checkArgument(appNamespace.getAppId(), appNamespace.getName()); + RequestPrecondition.checkArgumentsNotEmpty(appNamespace.getAppId(), appNamespace.getName()); if (!InputValidator.isValidAppNamespace(appNamespace.getName())) { throw new BadRequestException(String.format("Namespace格式错误: %s", - InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE + " & " - + InputValidator.INVALID_NAMESPACE_NAMESPACE_MESSAGE)); + InputValidator.INVALID_CLUSTER_NAMESPACE_MESSAGE + " & " + + InputValidator.INVALID_NAMESPACE_NAMESPACE_MESSAGE)); } //add app org id as prefix diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/NamespaceLockController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/NamespaceLockController.java index 44482d8a87987be6318024e54a622233fdb21020..db714f28340eca47501945fc30a79cccdd78b954 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/NamespaceLockController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/NamespaceLockController.java @@ -17,9 +17,9 @@ public class NamespaceLockController { @RequestMapping("/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/lock") public NamespaceLockDTO getNamespaceLock(@PathVariable String appId, @PathVariable String env, - @PathVariable String clusterName, @PathVariable String namespaceName){ + @PathVariable String clusterName, @PathVariable String namespaceName) { - return namespaceLockService.getNamespaceLock(appId, Env.valueOf(env), clusterName, namespaceName); + return namespaceLockService.getNamespaceLock(appId, Env.valueOf(env), clusterName, namespaceName); } } 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 dcf9669f471e091e551466b05cd07f5047c56194..47cadb4e3ac382abe5c96f87e508b966fecdc11b 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 @@ -3,6 +3,7 @@ package com.ctrip.framework.apollo.portal.controller; import com.google.common.collect.Sets; import com.ctrip.framework.apollo.common.exception.BadRequestException; +import com.ctrip.framework.apollo.common.utils.RequestPrecondition; import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.constant.RoleType; import com.ctrip.framework.apollo.portal.entity.po.UserInfo; @@ -26,8 +27,6 @@ import org.springframework.web.bind.annotation.RestController; import java.util.Set; -import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkArgument; - @RestController public class PermissionController { @@ -56,13 +55,13 @@ public class PermissionController { permissionCondition.setHasPermission( rolePermissionService.userHasPermission(userInfoHolder.getUser().getUserId(), permissionType, - RoleUtils.buildNamespaceTargetId(appId, namespaceName))); + RoleUtils.buildNamespaceTargetId(appId, namespaceName))); return ResponseEntity.ok().body(permissionCondition); } @RequestMapping("/permissions/root") - public ResponseEntity hasRootPermission(){ + public ResponseEntity hasRootPermission() { PermissionCondition permissionCondition = new PermissionCondition(); permissionCondition.setHasPermission(rolePermissionService.isSuperAdmin(userInfoHolder.getUser().getUserId())); @@ -72,7 +71,7 @@ public class PermissionController { @RequestMapping("/apps/{appId}/namespaces/{namespaceName}/role_users") - public NamespaceRolesAssignedUsers getNamespaceRoles(@PathVariable String appId, @PathVariable String namespaceName){ + public NamespaceRolesAssignedUsers getNamespaceRoles(@PathVariable String appId, @PathVariable String namespaceName) { NamespaceRolesAssignedUsers assignedUsers = new NamespaceRolesAssignedUsers(); assignedUsers.setNamespaceName(namespaceName); @@ -92,16 +91,16 @@ public class PermissionController { @PreAuthorize(value = "@permissionValidator.hasAssignRolePermission(#appId)") @RequestMapping(value = "/apps/{appId}/namespaces/{namespaceName}/roles/{roleType}", method = RequestMethod.POST) public ResponseEntity assignNamespaceRoleToUser(@PathVariable String appId, @PathVariable String namespaceName, - @PathVariable String roleType, @RequestBody String user){ + @PathVariable String roleType, @RequestBody String user) { checkUserExists(user); - checkArgument(user); + RequestPrecondition.checkArgumentsNotEmpty(user); - if (!RoleType.isValidRoleType(roleType)){ + if (!RoleType.isValidRoleType(roleType)) { throw new BadRequestException("role type is illegal"); } Set assignedUser = rolePermissionService.assignRoleToUsers(RoleUtils.buildNamespaceRoleName(appId, namespaceName, roleType), - Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); - if (CollectionUtils.isEmpty(assignedUser)){ + Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); + if (CollectionUtils.isEmpty(assignedUser)) { throw new BadRequestException(user + "已授权"); } @@ -111,19 +110,19 @@ public class PermissionController { @PreAuthorize(value = "@permissionValidator.hasAssignRolePermission(#appId)") @RequestMapping(value = "/apps/{appId}/namespaces/{namespaceName}/roles/{roleType}", method = RequestMethod.DELETE) public ResponseEntity removeNamespaceRoleFromUser(@PathVariable String appId, @PathVariable String namespaceName, - @PathVariable String roleType, @RequestParam String user){ - checkArgument(user); + @PathVariable String roleType, @RequestParam String user) { + RequestPrecondition.checkArgumentsNotEmpty(user); - if (!RoleType.isValidRoleType(roleType)){ + if (!RoleType.isValidRoleType(roleType)) { throw new BadRequestException("role type is illegal"); } rolePermissionService.removeRoleFromUsers(RoleUtils.buildNamespaceRoleName(appId, namespaceName, roleType), - Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); + Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); return ResponseEntity.ok().build(); } @RequestMapping(value = "/apps/{appId}/role_users") - public AppRolesAssignedUsers getAppRoles(@PathVariable String appId){ + public AppRolesAssignedUsers getAppRoles(@PathVariable String appId) { AppRolesAssignedUsers users = new AppRolesAssignedUsers(); users.setAppId(appId); @@ -136,16 +135,16 @@ public class PermissionController { @PreAuthorize(value = "@permissionValidator.hasAssignRolePermission(#appId)") @RequestMapping(value = "/apps/{appId}/roles/{roleType}", method = RequestMethod.POST) public ResponseEntity assignAppRoleToUser(@PathVariable String appId, @PathVariable String roleType, - @RequestBody String user){ + @RequestBody String user) { checkUserExists(user); - checkArgument(user); + RequestPrecondition.checkArgumentsNotEmpty(user); - if (!RoleType.isValidRoleType(roleType)){ + if (!RoleType.isValidRoleType(roleType)) { throw new BadRequestException("role type is illegal"); } Set assignedUsers = rolePermissionService.assignRoleToUsers(RoleUtils.buildAppRoleName(appId, roleType), - Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); - if (CollectionUtils.isEmpty(assignedUsers)){ + Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); + if (CollectionUtils.isEmpty(assignedUsers)) { throw new BadRequestException(user + "已授权"); } @@ -155,14 +154,14 @@ public class PermissionController { @PreAuthorize(value = "@permissionValidator.hasAssignRolePermission(#appId)") @RequestMapping(value = "/apps/{appId}/roles/{roleType}", method = RequestMethod.DELETE) public ResponseEntity removeAppRoleFromUser(@PathVariable String appId, @PathVariable String roleType, - @RequestParam String user){ - checkArgument(user); + @RequestParam String user) { + RequestPrecondition.checkArgumentsNotEmpty(user); - if (!RoleType.isValidRoleType(roleType)){ + if (!RoleType.isValidRoleType(roleType)) { throw new BadRequestException("role type is illegal"); } rolePermissionService.removeRoleFromUsers(RoleUtils.buildAppRoleName(appId, roleType), - Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); + Sets.newHashSet(user), userInfoHolder.getUser().getUserId()); return ResponseEntity.ok().build(); } 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 1795f48f62e0c6510de15b185269f233a96fc3a9..9d63eb3eefb2e449390f155fa7b7271f9bde8ca6 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 @@ -1,7 +1,7 @@ package com.ctrip.framework.apollo.portal.controller; -import com.ctrip.framework.apollo.common.utils.RequestPrecondition; import com.ctrip.framework.apollo.common.dto.ReleaseDTO; +import com.ctrip.framework.apollo.common.utils.RequestPrecondition; import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.portal.entity.form.NamespaceReleaseModel; import com.ctrip.framework.apollo.portal.entity.vo.ReleaseCompareResult; @@ -28,7 +28,7 @@ public class ReleaseController { private ReleaseService releaseService; @PreAuthorize(value = "@permissionValidator.hasReleaseNamespacePermission(#appId, #namespaceName)") - @RequestMapping(value = "/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/release") + @RequestMapping(value = "/apps/{appId}/envs/{env}/clusters/{clusterName}/namespaces/{namespaceName}/release", method = RequestMethod.POST) public ReleaseDTO createRelease(@PathVariable String appId, @PathVariable String env, @PathVariable String clusterName, @PathVariable String namespaceName, @RequestBody NamespaceReleaseModel model) { diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ServerConfigController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ServerConfigController.java index 93a22709a8bd124427c1cd143f456c1a21074eae..10e20a0e4a2156c63f4b1118b96a90956fa4d49b 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ServerConfigController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/ServerConfigController.java @@ -2,17 +2,18 @@ package com.ctrip.framework.apollo.portal.controller; import com.ctrip.framework.apollo.common.utils.BeanUtils; +import com.ctrip.framework.apollo.common.utils.RequestPrecondition; import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.entity.po.ServerConfig; import com.ctrip.framework.apollo.portal.repository.ServerConfigRepository; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.security.access.prepost.PreAuthorize; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; -import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkArgument; import static com.ctrip.framework.apollo.common.utils.RequestPrecondition.checkModel; /** @@ -26,11 +27,12 @@ public class ServerConfigController { @Autowired private UserInfoHolder userInfoHolder; + @PreAuthorize(value = "@permissionValidator.isSuperAdmin()") @RequestMapping(value = "/server/config", method = RequestMethod.POST) public ServerConfig createOrUpdate(@RequestBody ServerConfig serverConfig) { checkModel(serverConfig != null); - checkArgument(serverConfig.getKey(), serverConfig.getValue()); + RequestPrecondition.checkArgumentsNotEmpty(serverConfig.getKey(), serverConfig.getValue()); String modifiedBy = userInfoHolder.getUser().getUserId(); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/UserInfoController.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/UserInfoController.java index 9fb132e63d549a85163084b663220efe34840f25..16ab2e727517b643855d1ef7130de7c62d9e738d 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/UserInfoController.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/controller/UserInfoController.java @@ -30,7 +30,7 @@ public class UserInfoController { @RequestMapping("/user") public UserInfo getCurrentUserName() { - return userInfoHolder.getUser(); + return userInfoHolder.getUser(); } @RequestMapping("/user/logout") diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/customize/BizLoggingCustomizer.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/customize/BizLoggingCustomizer.java index 20410b77a93e53725833c5a36290e595a8c95aa2..11d10dfb4208e97cec201b664fd2029eeaeff91a 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/customize/BizLoggingCustomizer.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/customize/BizLoggingCustomizer.java @@ -9,7 +9,7 @@ import org.springframework.stereotype.Component; @Component @Profile("ctrip") -public class BizLoggingCustomizer extends LoggingCustomizer{ +public class BizLoggingCustomizer extends LoggingCustomizer { private static final String CLOGGING_SERVER_URL_KEY = "clogging.server.url"; private static final String CLOGGING_SERVER_PORT_KEY = "clogging.server.port"; @@ -22,7 +22,7 @@ public class BizLoggingCustomizer extends LoggingCustomizer{ @Override protected String cloggingUrl() { - if (cloggingUrl == null){ + if (cloggingUrl == null) { cloggingUrl = serverConfigService.getValue(CLOGGING_SERVER_URL_KEY); } return cloggingUrl; @@ -30,7 +30,7 @@ public class BizLoggingCustomizer extends LoggingCustomizer{ @Override protected String cloggingPort() { - if (cloggingPort == null){ + if (cloggingPort == null) { cloggingPort = serverConfigService.getValue(CLOGGING_SERVER_PORT_KEY); } return cloggingPort; diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceReleaseModel.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceReleaseModel.java index 52fe42f019821f5dfd4c461b905fcfce71760bd7..4243ed54545955f27ac7655072c466e69d310870 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceReleaseModel.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceReleaseModel.java @@ -12,6 +12,7 @@ public class NamespaceReleaseModel implements Verifiable { private String namespaceName; private String releaseTitle; private String releaseComment; + private String releasedBy; @Override public boolean isInvalid() { @@ -66,4 +67,11 @@ public class NamespaceReleaseModel implements Verifiable { this.releaseComment = releaseComment; } + public String getReleasedBy() { + return releasedBy; + } + + public void setReleasedBy(String releasedBy) { + this.releasedBy = releasedBy; + } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceSyncModel.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceSyncModel.java index 8bdae71d551d07c2033bc3b24374f45e84fa84ee..0bd5954add52f2a0e6c8b6d33fee73b193ac5283 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceSyncModel.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceSyncModel.java @@ -1,7 +1,7 @@ package com.ctrip.framework.apollo.portal.entity.form; import com.ctrip.framework.apollo.common.dto.ItemDTO; -import com.ctrip.framework.apollo.portal.entity.vo.NamespaceIdentifer; +import com.ctrip.framework.apollo.portal.entity.vo.NamespaceIdentifier; import org.springframework.util.CollectionUtils; @@ -9,27 +9,27 @@ import java.util.List; public class NamespaceSyncModel implements Verifiable { - private List syncToNamespaces; + private List syncToNamespaces; private List syncItems; @Override public boolean isInvalid() { - if (CollectionUtils.isEmpty(syncToNamespaces) || CollectionUtils.isEmpty(syncItems)){ + if (CollectionUtils.isEmpty(syncToNamespaces) || CollectionUtils.isEmpty(syncItems)) { return true; } - for (NamespaceIdentifer namespaceIdentifer: syncToNamespaces){ - if (namespaceIdentifer.isInvalid()){ + for (NamespaceIdentifier namespaceIdentifier : syncToNamespaces) { + if (namespaceIdentifier.isInvalid()) { return true; } } return false; } - public List getSyncToNamespaces() { + public List getSyncToNamespaces() { return syncToNamespaces; } - public void setSyncToNamespaces(List syncToNamespaces) { + public void setSyncToNamespaces(List syncToNamespaces) { this.syncToNamespaces = syncToNamespaces; } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceTextModel.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceTextModel.java index f2007548e75cdadea0ac4961ff622542ea4675a5..ecf1b84b31043efc552f03f7740f63dff2b30198 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceTextModel.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/form/NamespaceTextModel.java @@ -17,9 +17,10 @@ public class NamespaceTextModel implements Verifiable { @Override - public boolean isInvalid(){ + public boolean isInvalid() { return StringUtils.isContainEmpty(appId, env, clusterName, namespaceName) || namespaceId <= 0; } + public String getAppId() { return appId; } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/EnvClusterInfo.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/EnvClusterInfo.java index ecb3f232273dc1b1130512b37d64a36aac4ca242..b160d0e508c3cd243a4a4fe917c07b7c86c55e3d 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/EnvClusterInfo.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/EnvClusterInfo.java @@ -9,7 +9,7 @@ public class EnvClusterInfo { private Env env; private List clusters; - public EnvClusterInfo(Env env){ + public EnvClusterInfo(Env env) { this.env = env; } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/ItemDiffs.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/ItemDiffs.java index c30bcc79ce496c4aeede5052704b2259b4ba0368..6b30b99678fefbd96116d187b808430bb6b3b036 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/ItemDiffs.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/ItemDiffs.java @@ -3,18 +3,19 @@ package com.ctrip.framework.apollo.portal.entity.vo; import com.ctrip.framework.apollo.common.dto.ItemChangeSets; public class ItemDiffs { - private NamespaceIdentifer namespace; + private NamespaceIdentifier namespace; private ItemChangeSets diffs; private String extInfo; - public ItemDiffs(NamespaceIdentifer namespace){ + public ItemDiffs(NamespaceIdentifier namespace) { this.namespace = namespace; } - public NamespaceIdentifer getNamespace() { + + public NamespaceIdentifier getNamespace() { return namespace; } - public void setNamespace(NamespaceIdentifer namespace) { + public void setNamespace(NamespaceIdentifier namespace) { this.namespace = namespace; } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceIdentifer.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceIdentifier.java similarity index 81% rename from apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceIdentifer.java rename to apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceIdentifier.java index 3408974c771ce1db8946c616ede3ede00c6e2995..e6b783c8ffdffceb04dc17b89eb3c1c62af8f0ad 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceIdentifer.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceIdentifier.java @@ -4,7 +4,7 @@ import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.core.utils.StringUtils; import com.ctrip.framework.apollo.portal.entity.form.Verifiable; -public class NamespaceIdentifer implements Verifiable { +public class NamespaceIdentifier implements Verifiable { private String appId; private String env; private String clusterName; @@ -51,10 +51,10 @@ public class NamespaceIdentifer implements Verifiable { @Override public String toString() { return "NamespaceIdentifer{" + - "appId='" + appId + '\'' + - ", env='" + env + '\'' + - ", clusterName='" + clusterName + '\'' + - ", namespaceName='" + namespaceName + '\'' + - '}'; + "appId='" + appId + '\'' + + ", env='" + env + '\'' + + ", clusterName='" + clusterName + '\'' + + ", namespaceName='" + namespaceName + '\'' + + '}'; } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceVO.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceVO.java index b45719df2bc4838653fa62cd5fadd81104f559c8..7b2f9e74b3466bd7dd40feb6281c3b5ae3188a75 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceVO.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/entity/vo/NamespaceVO.java @@ -1,4 +1,5 @@ package com.ctrip.framework.apollo.portal.entity.vo; + import com.ctrip.framework.apollo.common.dto.ItemDTO; import com.ctrip.framework.apollo.common.dto.NamespaceDTO; @@ -70,7 +71,7 @@ public class NamespaceVO { this.comment = comment; } - public static class ItemVO{ + public static class ItemVO { private ItemDTO item; private boolean isModified; private boolean isDeleted; @@ -118,7 +119,6 @@ public class NamespaceVO { } - } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/enums/ChangeType.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/enums/ChangeType.java index e005bc5f4c85ded182fb6e4e329c27ecf0f17c9b..32e4438359e019a01e2772c179348bee4a8f0020 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/enums/ChangeType.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/enums/ChangeType.java @@ -1,5 +1,5 @@ package com.ctrip.framework.apollo.portal.enums; -public enum ChangeType { +public enum ChangeType { ADDED, MODIFIED, DELETED } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/listener/CreationListener.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/listener/CreationListener.java index ea78c9e493e8eaaa946de91abc06267f775ca684..367b259f0df841763c4b095f05d45cd2662f3996 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/listener/CreationListener.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/listener/CreationListener.java @@ -1,8 +1,8 @@ package com.ctrip.framework.apollo.portal.listener; -import com.ctrip.framework.apollo.common.utils.BeanUtils; import com.ctrip.framework.apollo.common.dto.AppDTO; import com.ctrip.framework.apollo.common.dto.AppNamespaceDTO; +import com.ctrip.framework.apollo.common.utils.BeanUtils; import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.portal.PortalSettings; import com.ctrip.framework.apollo.portal.api.AdminServiceAPI; @@ -43,7 +43,7 @@ public class CreationListener { } @EventListener - public void onAppNamespaceCreationEvent(AppNamespaceCreationEvent event){ + public void onAppNamespaceCreationEvent(AppNamespaceCreationEvent event) { AppNamespaceDTO appNamespace = BeanUtils.transfrom(AppNamespaceDTO.class, event.getAppNamespace()); List envs = portalSettings.getActiveEnvs(); for (Env env : envs) { diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/AppNamespaceRepository.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/AppNamespaceRepository.java index 4c6bac0d552a9931af3007835c8d93cb61370020..59b1780060c07eba49220b93ef84c670810d6ac2 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/AppNamespaceRepository.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/AppNamespaceRepository.java @@ -6,7 +6,7 @@ import org.springframework.data.repository.PagingAndSortingRepository; import java.util.List; -public interface AppNamespaceRepository extends PagingAndSortingRepository{ +public interface AppNamespaceRepository extends PagingAndSortingRepository { AppNamespace findByAppIdAndName(String appId, String namespaceName); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/PermissionRepository.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/PermissionRepository.java index 2388e79b5737b9577a563c0ef216d286e8ca650e..20029a043bc67e7819d768b519b491041a82ce56 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/PermissionRepository.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/PermissionRepository.java @@ -18,10 +18,7 @@ public interface PermissionRepository extends PagingAndSortingRepository findByPermissionTypeInAndTargetId(Collection permissionTypes, - String targetId); + String targetId); } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/RoleRepository.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/RoleRepository.java index c2cf3829a63171fdac6d740ee65ed39169882165..b203ae7b4d3a0ebfa3304e3d61550e3e590a8085 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/RoleRepository.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/RoleRepository.java @@ -10,8 +10,6 @@ import org.springframework.data.repository.PagingAndSortingRepository; public interface RoleRepository extends PagingAndSortingRepository { /** * find role by role name - * @param roleName - * @return */ Role findTopByRoleName(String roleName); } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/UserRoleRepository.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/UserRoleRepository.java index 80471ceed8a6415b8a950a26e0c47b374c32e246..e52cd680b3d37879072f58581049b18219880f85 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/UserRoleRepository.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/repository/UserRoleRepository.java @@ -6,7 +6,6 @@ import org.springframework.data.repository.PagingAndSortingRepository; import java.util.Collection; import java.util.List; -import java.util.Set; /** * @author Jason Song(song_s@ctrip.com) @@ -14,23 +13,16 @@ import java.util.Set; public interface UserRoleRepository extends PagingAndSortingRepository { /** * find user roles by userId - * @param userId - * @return */ List findByUserId(String userId); /** * find user roles by roleId - * @param roleId - * @return */ List findByRoleId(long roleId); /** * find user roles by userIds and roleId - * @param userId - * @param roleId - * @return */ List findByUserIdInAndRoleId(Collection userId, long roleId); } 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 e719efeb6943af68b30d4181a02047ea382f18d1..578dc01b4f28a23030e21aceb6fe823b395962b1 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 @@ -1,10 +1,10 @@ package com.ctrip.framework.apollo.portal.service; import com.ctrip.framework.apollo.common.entity.AppNamespace; -import com.ctrip.framework.apollo.core.ConfigConsts; -import com.ctrip.framework.apollo.core.enums.ConfigFileFormat; import com.ctrip.framework.apollo.common.exception.BadRequestException; import com.ctrip.framework.apollo.common.exception.ServiceException; +import com.ctrip.framework.apollo.core.ConfigConsts; +import com.ctrip.framework.apollo.core.enums.ConfigFileFormat; import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.repository.AppNamespaceRepository; 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 b149f04da56af0dec613a820dcaa322129c22df9..2e21ec8fd3dbf60a8e05972626c0f6c055e05e35 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 @@ -2,22 +2,12 @@ package com.ctrip.framework.apollo.portal.service; import com.google.common.collect.Lists; -import java.util.Collections; -import java.util.List; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Service; -import org.springframework.transaction.annotation.Transactional; -import org.springframework.web.client.HttpStatusCodeException; - +import com.ctrip.framework.apollo.common.dto.AppDTO; import com.ctrip.framework.apollo.common.entity.App; +import com.ctrip.framework.apollo.common.exception.BadRequestException; import com.ctrip.framework.apollo.common.utils.BeanUtils; import com.ctrip.framework.apollo.common.utils.ExceptionUtils; -import com.ctrip.framework.apollo.common.dto.AppDTO; import com.ctrip.framework.apollo.core.enums.Env; -import com.ctrip.framework.apollo.common.exception.BadRequestException; import com.ctrip.framework.apollo.portal.api.AdminServiceAPI; import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.constant.CatEventType; @@ -25,6 +15,16 @@ import com.ctrip.framework.apollo.portal.entity.vo.EnvClusterInfo; import com.ctrip.framework.apollo.portal.repository.AppRepository; import com.dianping.cat.Cat; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.client.HttpStatusCodeException; + +import java.util.Collections; +import java.util.List; + @Service public class AppService { @@ -49,14 +49,14 @@ public class AppService { public List findAll() { Iterable apps = appRepository.findAll(); if (apps == null) { - return Collections.EMPTY_LIST; + return Collections.emptyList(); } return Lists.newArrayList((apps)); } public App load(String appId) { App app = appRepository.findByAppId(appId); - if (app == null){ + if (app == null) { throw new BadRequestException(String.format("app %s cant found.", appId)); } return app; 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 b322b83d5a016fa3856fb400a5665fa0caefe9a6..e00c4f1e678132b76a88ffd2c640548000e33802 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 @@ -1,8 +1,8 @@ package com.ctrip.framework.apollo.portal.service; -import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.common.dto.ClusterDTO; import com.ctrip.framework.apollo.common.exception.BadRequestException; +import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.portal.api.AdminServiceAPI; import com.ctrip.framework.apollo.portal.constant.CatEventType; import com.dianping.cat.Cat; @@ -18,12 +18,12 @@ public class ClusterService { @Autowired private AdminServiceAPI.ClusterAPI clusterAPI; - public List findClusters(Env env, String appId){ + public List findClusters(Env env, String appId) { return clusterAPI.findClustersByApp(appId, env); } - public ClusterDTO createCluster(Env env, ClusterDTO cluster){ - if (!clusterAPI.isClusterUnique(cluster.getAppId(), env, cluster.getName())){ + public ClusterDTO createCluster(Env env, ClusterDTO cluster) { + if (!clusterAPI.isClusterUnique(cluster.getAppId(), env, cluster.getName())) { throw new BadRequestException(String.format("cluster %s already exists.", cluster.getName())); } ClusterDTO clusterDTO = clusterAPI.create(env, cluster); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/CommitService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/CommitService.java index 2f9a9814e0ee7cdf2318c3ea7afdb7835aae82ac..13cbdfa631624c33c26f07a87b8d56ef9fd69e7a 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/CommitService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/CommitService.java @@ -16,7 +16,7 @@ public class CommitService { @Autowired private AdminServiceAPI.CommitAPI commitAPI; - public List find(String appId, Env env, String clusterName, String namespaceName, int page, int size){ + public List find(String appId, Env env, String clusterName, String namespaceName, int page, int size) { return commitAPI.find(appId, env, clusterName, namespaceName, page, size); } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ConfigService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ItemService.java similarity index 79% rename from apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ConfigService.java rename to apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ItemService.java index 9ef03b22956a215d7670963a62a24731122fb91c..d97c8b0f3ec5a02406580e92161b44046f165599 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ConfigService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ItemService.java @@ -1,36 +1,36 @@ package com.ctrip.framework.apollo.portal.service; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Qualifier; -import org.springframework.http.HttpStatus; -import org.springframework.stereotype.Service; -import org.springframework.util.CollectionUtils; -import org.springframework.web.client.HttpClientErrorException; - -import com.ctrip.framework.apollo.common.utils.BeanUtils; -import com.ctrip.framework.apollo.core.enums.ConfigFileFormat; -import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.common.dto.ItemChangeSets; import com.ctrip.framework.apollo.common.dto.ItemDTO; import com.ctrip.framework.apollo.common.dto.NamespaceDTO; import com.ctrip.framework.apollo.common.exception.BadRequestException; +import com.ctrip.framework.apollo.common.utils.BeanUtils; +import com.ctrip.framework.apollo.core.enums.ConfigFileFormat; +import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.core.utils.StringUtils; import com.ctrip.framework.apollo.portal.api.AdminServiceAPI; import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.constant.CatEventType; -import com.ctrip.framework.apollo.portal.entity.vo.ItemDiffs; -import com.ctrip.framework.apollo.portal.entity.vo.NamespaceIdentifer; import com.ctrip.framework.apollo.portal.entity.form.NamespaceTextModel; +import com.ctrip.framework.apollo.portal.entity.vo.ItemDiffs; +import com.ctrip.framework.apollo.portal.entity.vo.NamespaceIdentifier; import com.ctrip.framework.apollo.portal.service.txtresolver.ConfigTextResolver; import com.dianping.cat.Cat; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.http.HttpStatus; +import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; +import org.springframework.web.client.HttpClientErrorException; + import java.util.LinkedList; import java.util.List; import java.util.Map; @Service -public class ConfigService { +public class ItemService { @Autowired private UserInfoHolder userInfoHolder; @@ -38,8 +38,6 @@ public class ConfigService { private AdminServiceAPI.NamespaceAPI namespaceAPI; @Autowired private AdminServiceAPI.ItemAPI itemAPI; - @Autowired - private AdminServiceAPI.ReleaseAPI releaseAPI; @Autowired @Qualifier("fileTextResolver") @@ -67,7 +65,7 @@ public class ConfigService { model.getFormat() == ConfigFileFormat.Properties ? propertyResolver : fileTextResolver; ItemChangeSets changeSets = resolver.resolve(namespaceId, configText, - itemAPI.findItems(appId, env, clusterName, namespaceName)); + itemAPI.findItems(appId, env, clusterName, namespaceName)); if (changeSets.isEmpty()) { return; } @@ -76,7 +74,7 @@ public class ConfigService { itemAPI.updateItemsByChangeSet(appId, env, clusterName, namespaceName, changeSets); Cat.logEvent(CatEventType.MODIFY_NAMESPACE_BY_TEXT, - String.format("%s+%s+%s+%s", appId, env, clusterName, namespaceName)); + String.format("%s+%s+%s+%s", appId, env, clusterName, namespaceName)); Cat.logEvent(CatEventType.MODIFY_NAMESPACE, String.format("%s+%s+%s+%s", appId, env, clusterName, namespaceName)); } @@ -89,9 +87,11 @@ public class ConfigService { } item.setNamespaceId(namespace.getId()); - String username = userInfoHolder.getUser().getUserId(); - item.setDataChangeCreatedBy(username); - item.setDataChangeLastModifiedBy(username); + if (StringUtils.isEmpty(item.getDataChangeCreatedBy())) { + String username = userInfoHolder.getUser().getUserId(); + item.setDataChangeCreatedBy(username); + item.setDataChangeLastModifiedBy(username); + } ItemDTO itemDTO = itemAPI.createItem(appId, env, clusterName, namespaceName, item); Cat.logEvent(CatEventType.MODIFY_NAMESPACE, String.format("%s+%s+%s+%s", appId, env, clusterName, namespaceName)); @@ -99,30 +99,36 @@ public class ConfigService { } public void updateItem(String appId, Env env, String clusterName, String namespaceName, ItemDTO item) { - String username = userInfoHolder.getUser().getUserId(); - item.setDataChangeLastModifiedBy(username); + if (StringUtils.isEmpty(item.getDataChangeLastModifiedBy())) { + String username = userInfoHolder.getUser().getUserId(); + item.setDataChangeLastModifiedBy(username); + } itemAPI.updateItem(appId, env, clusterName, namespaceName, item.getId(), item); } - public void deleteItem(Env env, long itemId) { - itemAPI.deleteItem(env, itemId, userInfoHolder.getUser().getUserId()); + public void deleteItem(Env env, long itemId, String userId) { + itemAPI.deleteItem(env, itemId, userId); } public List findItems(String appId, Env env, String clusterName, String namespaceName) { return itemAPI.findItems(appId, env, clusterName, namespaceName); } - public void syncItems(List comparedNamespaces, List sourceItems) { + public ItemDTO loadItem(Env env, long itemId) { + return itemAPI.loadItem(env, itemId); + } + + public void syncItems(List comparedNamespaces, List sourceItems) { List itemDiffs = compare(comparedNamespaces, sourceItems); for (ItemDiffs itemDiff : itemDiffs) { - NamespaceIdentifer namespaceIdentifer = itemDiff.getNamespace(); + NamespaceIdentifier namespaceIdentifier = itemDiff.getNamespace(); ItemChangeSets changeSets = itemDiff.getDiffs(); changeSets.setDataChangeLastModifiedBy(userInfoHolder.getUser().getUserId()); - String appId = namespaceIdentifer.getAppId(); - Env env = namespaceIdentifer.getEnv(); - String clusterName = namespaceIdentifer.getClusterName(); - String namespaceName = namespaceIdentifer.getNamespaceName(); + String appId = namespaceIdentifier.getAppId(); + Env env = namespaceIdentifier.getEnv(); + String clusterName = namespaceIdentifier.getClusterName(); + String namespaceName = namespaceIdentifier.getNamespaceName(); itemAPI.updateItemsByChangeSet(appId, env, clusterName, namespaceName, changeSets); @@ -130,11 +136,11 @@ public class ConfigService { } } - public List compare(List comparedNamespaces, List sourceItems) { + public List compare(List comparedNamespaces, List sourceItems) { List result = new LinkedList<>(); - for (NamespaceIdentifer namespace : comparedNamespaces) { + for (NamespaceIdentifier namespace : comparedNamespaces) { ItemDiffs itemDiffs = new ItemDiffs(namespace); try { @@ -149,11 +155,11 @@ public class ConfigService { return result; } - private long getNamespaceId(NamespaceIdentifer namespaceIdentifer) { - String appId = namespaceIdentifer.getAppId(); - String clusterName = namespaceIdentifer.getClusterName(); - String namespaceName = namespaceIdentifer.getNamespaceName(); - Env env = namespaceIdentifer.getEnv(); + private long getNamespaceId(NamespaceIdentifier namespaceIdentifier) { + String appId = namespaceIdentifier.getAppId(); + String clusterName = namespaceIdentifier.getClusterName(); + String namespaceName = namespaceIdentifier.getNamespaceName(); + Env env = namespaceIdentifier.getEnv(); NamespaceDTO namespaceDTO = null; try { namespaceDTO = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); @@ -167,12 +173,12 @@ public class ConfigService { return namespaceDTO.getId(); } - private ItemChangeSets parseChangeSets(NamespaceIdentifer namespace, List sourceItems) { + private ItemChangeSets parseChangeSets(NamespaceIdentifier namespace, List sourceItems) { ItemChangeSets changeSets = new ItemChangeSets(); List targetItems = itemAPI.findItems(namespace.getAppId(), namespace.getEnv(), - namespace.getClusterName(), namespace.getNamespaceName()); + namespace.getClusterName(), namespace.getNamespaceName()); long namespaceId = getNamespaceId(namespace); @@ -197,7 +203,7 @@ public class ConfigService { changeSets.addCreateItem(buildItem(namespaceId, ++maxLineNum, sourceItem)); } else if (isModified(sourceValue, targetItem.getValue(), sourceComment, - targetItem.getComment())) {//modified items + targetItem.getComment())) {//modified items targetItem.setValue(sourceValue); targetItem.setComment(sourceComment); changeSets.addUpdateItem(targetItem); diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceLockService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceLockService.java index 2359bb7e7493c456be8e56a90052d9da1cb47f49..d7acbf65c75e9c4ac5c8b4308a3c83d52c5b1a11 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceLockService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/NamespaceLockService.java @@ -13,7 +13,7 @@ public class NamespaceLockService { @Autowired private AdminServiceAPI.NamespaceLockAPI namespaceLockAPI; - public NamespaceLockDTO getNamespaceLock(String appId, Env env, String clusterName, String namespaceName){ + public NamespaceLockDTO getNamespaceLock(String appId, Env env, String clusterName, String namespaceName) { return namespaceLockAPI.getNamespaceLockOwner(appId, env, clusterName, namespaceName); } 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 e87b35b45f4ecdac5756dda0456c9a8ab1348eac..fef1b21d54194d898fe9c37e16e2925c972f736f 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 @@ -2,11 +2,12 @@ package com.ctrip.framework.apollo.portal.service; import com.google.gson.Gson; -import com.ctrip.framework.apollo.common.entity.AppNamespace; -import com.ctrip.framework.apollo.common.utils.BeanUtils; import com.ctrip.framework.apollo.common.dto.ItemDTO; import com.ctrip.framework.apollo.common.dto.NamespaceDTO; import com.ctrip.framework.apollo.common.dto.ReleaseDTO; +import com.ctrip.framework.apollo.common.entity.AppNamespace; +import com.ctrip.framework.apollo.common.exception.BadRequestException; +import com.ctrip.framework.apollo.common.utils.BeanUtils; import com.ctrip.framework.apollo.core.enums.ConfigFileFormat; import com.ctrip.framework.apollo.core.enums.Env; import com.ctrip.framework.apollo.core.utils.StringUtils; @@ -21,7 +22,6 @@ import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; -import java.util.Collections; import java.util.HashMap; import java.util.LinkedList; import java.util.List; @@ -36,9 +36,9 @@ public class NamespaceService { @Autowired private UserInfoHolder userInfoHolder; @Autowired - private AdminServiceAPI.ItemAPI itemAPI; + private ItemService itemService; @Autowired - private AdminServiceAPI.ReleaseAPI releaseAPI; + private ReleaseService releaseService; @Autowired private AdminServiceAPI.NamespaceAPI namespaceAPI; @Autowired @@ -53,11 +53,18 @@ public class NamespaceService { NamespaceDTO createdNamespace = namespaceAPI.createNamespace(env, namespace); Cat.logEvent(CatEventType.CREATE_NAMESPACE, - String.format("%s+%s+%s+%s", namespace.getAppId(), env, namespace.getClusterName(), - namespace.getNamespaceName())); + String.format("%s+%s+%s+%s", namespace.getAppId(), env, namespace.getClusterName(), + namespace.getNamespaceName())); return createdNamespace; } + public NamespaceDTO loadNamespaceBaseInfo(String appId, Env env, String clusterName, String namespaceName) { + NamespaceDTO namespace = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); + if (namespace == null) { + throw new BadRequestException("namespaces not exist"); + } + return namespace; + } /** * load cluster all namespace info with items @@ -66,7 +73,7 @@ public class NamespaceService { List namespaces = namespaceAPI.findNamespaceByCluster(appId, env, clusterName); if (namespaces == null || namespaces.size() == 0) { - return Collections.emptyList(); + throw new BadRequestException("namespaces not exist"); } List namespaceVOs = new LinkedList<>(); @@ -78,7 +85,7 @@ public class NamespaceService { namespaceVOs.add(namespaceVO); } catch (Exception e) { logger.error("parse namespace error. app id:{}, env:{}, clusterName:{}, namespace:{}", - appId, env, clusterName, namespace.getNamespaceName(), e); + appId, env, clusterName, namespace.getNamespaceName(), e); throw e; } } @@ -86,6 +93,14 @@ public class NamespaceService { return namespaceVOs; } + public NamespaceVO loadNamespace(String appId, Env env, String clusterName, String namespaceName) { + NamespaceDTO namespace = namespaceAPI.loadNamespace(appId, env, clusterName, namespaceName); + if (namespace == null) { + throw new BadRequestException("namespaces not exist"); + } + return parseNamespace(appId, env, clusterName, namespace); + } + @SuppressWarnings("unchecked") private NamespaceVO parseNamespace(String appId, Env env, String clusterName, NamespaceDTO namespace) { NamespaceVO namespaceVO = new NamespaceVO(); @@ -101,13 +116,13 @@ public class NamespaceService { //latest Release ReleaseDTO latestRelease = null; Map releaseItems = new HashMap<>(); - latestRelease = releaseAPI.loadLatestRelease(appId, env, clusterName, namespaceName); + latestRelease = releaseService.loadLatestRelease(appId, env, clusterName, namespaceName); if (latestRelease != null) { releaseItems = gson.fromJson(latestRelease.getConfigurations(), Map.class); } //not Release config items - List items = itemAPI.findItems(appId, env, clusterName, namespaceName); + List items = itemService.findItems(appId, env, clusterName, namespaceName); int modifiedItemCnt = 0; for (ItemDTO itemDTO : items) { diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ReleaseService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ReleaseService.java index d5404d0307fce7a1e5ca7ab373b0b7cc6d1c7472..2cb641816c6bb2e967b17de0034fbbd16cc3fb7f 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ReleaseService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/ReleaseService.java @@ -2,9 +2,11 @@ package com.ctrip.framework.apollo.portal.service; import com.google.common.base.Objects; import com.google.gson.Gson; +import com.google.gson.reflect.TypeToken; import com.ctrip.framework.apollo.common.dto.ReleaseDTO; import com.ctrip.framework.apollo.core.enums.Env; +import com.ctrip.framework.apollo.core.utils.StringUtils; import com.ctrip.framework.apollo.portal.api.AdminServiceAPI; import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.constant.CatEventType; @@ -19,6 +21,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.util.CollectionUtils; +import java.lang.reflect.Type; import java.util.Collections; import java.util.LinkedHashSet; import java.util.LinkedList; @@ -28,8 +31,10 @@ import java.util.Set; @Service public class ReleaseService { - private static final Gson gson = new Gson(); + private static final Type configurationTypeReference = + new TypeToken>() { + }.getType(); @Autowired private UserInfoHolder userInfoHolder; @@ -41,10 +46,13 @@ public class ReleaseService { Env env = model.getEnv(); String clusterName = model.getClusterName(); String namespaceName = model.getNamespaceName(); - ReleaseDTO releaseDTO = - releaseAPI - .createRelease(appId, env, clusterName, namespaceName, model.getReleaseTitle(), model.getReleaseComment() - , userInfoHolder.getUser().getUserId()); + String releaseBy = + StringUtils.isEmpty(model.getReleasedBy()) ? userInfoHolder.getUser().getUserId() : model.getReleasedBy(); + + ReleaseDTO releaseDTO = releaseAPI + .createRelease(appId, env, clusterName, namespaceName, model.getReleaseTitle(), model.getReleaseComment() + , releaseBy); + Cat.logEvent(CatEventType.RELEASE_NAMESPACE, String.format("%s+%s+%s+%s", appId, env, clusterName, namespaceName)); return releaseDTO; } @@ -54,7 +62,7 @@ public class ReleaseService { List releaseDTOs = releaseAPI.findAllReleases(appId, env, clusterName, namespaceName, page, size); if (CollectionUtils.isEmpty(releaseDTOs)) { - return Collections.EMPTY_LIST; + return Collections.emptyList(); } List releases = new LinkedList<>(); @@ -63,7 +71,8 @@ public class ReleaseService { release.setBaseInfo(releaseDTO); Set kvEntities = new LinkedHashSet<>(); - Set entries = gson.fromJson(releaseDTO.getConfigurations(), Map.class).entrySet(); + Map configurations = gson.fromJson(releaseDTO.getConfigurations(), configurationTypeReference); + Set> entries = configurations.entrySet(); for (Map.Entry entry : entries) { kvEntities.add(new KVEntity(entry.getKey(), entry.getValue())); } @@ -81,6 +90,10 @@ public class ReleaseService { return releaseAPI.findActiveReleases(appId, env, clusterName, namespaceName, page, size); } + public ReleaseDTO loadLatestRelease(String appId, Env env, String clusterName, String namespaceName) { + return releaseAPI.loadLatestRelease(appId, env, clusterName, namespaceName); + } + public void rollback(Env env, long releaseId) { releaseAPI.rollback(env, releaseId, userInfoHolder.getUser().getUserId()); } @@ -89,8 +102,8 @@ public class ReleaseService { ReleaseDTO firstRelease = releaseAPI.loadRelease(env, firstReleaseId); ReleaseDTO secondRelease = releaseAPI.loadRelease(env, secondReleaseId); - Map firstItems = gson.fromJson(firstRelease.getConfigurations(), Map.class); - Map secondItems = gson.fromJson(secondRelease.getConfigurations(), Map.class); + Map firstItems = gson.fromJson(firstRelease.getConfigurations(), configurationTypeReference); + Map secondItems = gson.fromJson(secondRelease.getConfigurations(), configurationTypeReference); ReleaseCompareResult compareResult = new ReleaseCompareResult(); @@ -102,10 +115,10 @@ public class ReleaseService { //added if (secondValue == null) { compareResult.addEntityPair(ChangeType.DELETED, new KVEntity(key, firstValue), - new KVEntity(key, secondValue)); + new KVEntity(key, secondValue)); } else if (!Objects.equal(firstValue, secondValue)) { compareResult.addEntityPair(ChangeType.MODIFIED, new KVEntity(key, firstValue), - new KVEntity(key, secondValue)); + new KVEntity(key, secondValue)); } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/RoleInitializationService.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/RoleInitializationService.java index 41d2064028b2654488eedd5236644a5e130985f8..b79526791080b63f1ca39925e7cc9760c38798be 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/RoleInitializationService.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/RoleInitializationService.java @@ -33,7 +33,7 @@ public class RoleInitializationService { String appMasterRoleName = RoleUtils.buildAppMasterRoleName(appId); //has created before - if (rolePermissionService.findRoleByRoleName(appMasterRoleName) != null){ + if (rolePermissionService.findRoleByRoleName(appMasterRoleName) != null) { return; } String operaterUserId = userInfoHolder.getUser().getUserId(); @@ -43,7 +43,7 @@ public class RoleInitializationService { //assign master role to user rolePermissionService .assignRoleToUsers(RoleUtils.buildAppMasterRoleName(appId), Sets.newHashSet(app.getOwnerName()), - operaterUserId); + operaterUserId); initNamespaceRoles(appId, ConfigConsts.NAMESPACE_APPLICATION); @@ -55,13 +55,13 @@ public class RoleInitializationService { String modifyNamespaceRoleName = RoleUtils.buildModifyNamespaceRoleName(appId, namespaceName); if (rolePermissionService.findRoleByRoleName(modifyNamespaceRoleName) == null) { createDefaultNamespaceRole(appId, namespaceName, PermissionType.MODIFY_NAMESPACE, - RoleUtils.buildModifyNamespaceRoleName(appId, namespaceName)); + RoleUtils.buildModifyNamespaceRoleName(appId, namespaceName)); } String releaseNamespaceRoleName = RoleUtils.buildReleaseNamespaceRoleName(appId, namespaceName); if (rolePermissionService.findRoleByRoleName(releaseNamespaceRoleName) == null) { createDefaultNamespaceRole(appId, namespaceName, PermissionType.RELEASE_NAMESPACE, - RoleUtils.buildReleaseNamespaceRoleName(appId, namespaceName)); + RoleUtils.buildReleaseNamespaceRoleName(appId, namespaceName)); } } diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/txtresolver/FileTextResolver.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/txtresolver/FileTextResolver.java index 0a319812e0da6f52864b4a928ddd7eb736a35c8c..dfa528e8fdd004220cc39cb5fd67e4ca3631b5be 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/txtresolver/FileTextResolver.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/txtresolver/FileTextResolver.java @@ -1,8 +1,8 @@ package com.ctrip.framework.apollo.portal.service.txtresolver; -import com.ctrip.framework.apollo.core.ConfigConsts; import com.ctrip.framework.apollo.common.dto.ItemChangeSets; import com.ctrip.framework.apollo.common.dto.ItemDTO; +import com.ctrip.framework.apollo.core.ConfigConsts; import com.ctrip.framework.apollo.core.utils.StringUtils; import org.springframework.stereotype.Component; diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/txtresolver/PropertyResolver.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/txtresolver/PropertyResolver.java index 6f6fe095db7125655438b909bd1415fe792d28c8..e717b6d5991c5226574990d7d1b393aee95ea5b6 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/txtresolver/PropertyResolver.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/service/txtresolver/PropertyResolver.java @@ -35,7 +35,7 @@ public class PropertyResolver implements ConfigTextResolver { String[] newItems = configText.split(ITEM_SEPARATOR); - if (isHasRepeatKey(newItems)){ + if (isHasRepeatKey(newItems)) { throw new BadRequestException("config text has repeat key please check."); } @@ -71,27 +71,27 @@ public class PropertyResolver implements ConfigTextResolver { return changeSets; } - private boolean isHasRepeatKey(String[] newItems){ + private boolean isHasRepeatKey(String[] newItems) { Set keys = new HashSet<>(); int lineCounter = 1; int keyCount = 0; - for (String item: newItems){ - if (!isCommentItem(item) && !isBlankItem(item)){ + for (String item : newItems) { + if (!isCommentItem(item) && !isBlankItem(item)) { keyCount++; String[] kv = parseKeyValueFromItem(item); if (kv != null) { keys.add(kv[0]); - }else { + } else { throw new BadRequestException("line:" + lineCounter + " key value must separate by '='"); } } - lineCounter ++; + lineCounter++; } return keyCount > keys.size(); } - private String[] parseKeyValueFromItem(String item){ + private String[] parseKeyValueFromItem(String item) { int kvSeparator = item.indexOf(KV_SEPARATOR); if (kvSeparator == -1) { return null; @@ -118,7 +118,7 @@ public class PropertyResolver implements ConfigTextResolver { } private void handleNormalLine(Long namespaceId, Map keyMapOldItem, String newItem, - int lineCounter, ItemChangeSets changeSets) { + int lineCounter, ItemChangeSets changeSets) { String[] kv = parseKeyValueFromItem(newItem); @@ -133,17 +133,17 @@ public class PropertyResolver implements ConfigTextResolver { if (oldItem == null) {//new item changeSets.addCreateItem(buildNormalItem(0l, namespaceId, newKey, newValue, "", lineCounter)); - } else if (!newValue.equals(oldItem.getValue()) || lineCounter != oldItem.getLineNum()){//update item + } else if (!newValue.equals(oldItem.getValue()) || lineCounter != oldItem.getLineNum()) {//update item changeSets.addUpdateItem( buildNormalItem(oldItem.getId(), namespaceId, newKey, newValue, oldItem.getComment(), - lineCounter)); + lineCounter)); } keyMapOldItem.remove(newKey); } private boolean isCommentItem(ItemDTO item) { return item != null && "".equals(item.getKey()) - && (item.getComment().startsWith("#") || item.getComment().startsWith("!")); + && (item.getComment().startsWith("#") || item.getComment().startsWith("!")); } private boolean isCommentItem(String line) { diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/util/RoleUtils.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/util/RoleUtils.java index 15a5acdcee0ab35462b34b68e471f08a2d0cb89c..b43842324546214eaeb69103c1a06baad126e4d7 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/util/RoleUtils.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/util/RoleUtils.java @@ -9,38 +9,39 @@ public class RoleUtils { private static final Joiner STRING_JOINER = Joiner.on(ConfigConsts.CLUSTER_NAMESPACE_SEPARATOR); - public static String buildAppMasterRoleName(String appId){ + public static String buildAppMasterRoleName(String appId) { return STRING_JOINER.join(RoleType.MASTER, appId); } - public static String buildAppRoleName(String appId, String roleType){ + public static String buildAppRoleName(String appId, String roleType) { return STRING_JOINER.join(roleType, appId); } - public static String buildModifyNamespaceRoleName(String appId, String namespaceName){ + + public static String buildModifyNamespaceRoleName(String appId, String namespaceName) { return STRING_JOINER.join(RoleType.MODIFY_NAMESPACE, appId, namespaceName); } - public static String buildModifyDefaultNamespaceRoleName(String appId){ + public static String buildModifyDefaultNamespaceRoleName(String appId) { return STRING_JOINER.join(RoleType.MODIFY_NAMESPACE, appId, ConfigConsts.NAMESPACE_APPLICATION); } - public static String buildReleaseNamespaceRoleName(String appId, String namespaceName){ + public static String buildReleaseNamespaceRoleName(String appId, String namespaceName) { return STRING_JOINER.join(RoleType.RELEASE_NAMESPACE, appId, namespaceName); } - public static String buildNamespaceRoleName(String appId, String namespaceName, String roleType){ + public static String buildNamespaceRoleName(String appId, String namespaceName, String roleType) { return STRING_JOINER.join(roleType, appId, namespaceName); } - public static String buildReleaseDefaultNamespaceRoleName(String appId){ + public static String buildReleaseDefaultNamespaceRoleName(String appId) { return STRING_JOINER.join(RoleType.RELEASE_NAMESPACE, appId, ConfigConsts.NAMESPACE_APPLICATION); } - public static String buildNamespaceTargetId(String appId, String namespaceName){ + public static String buildNamespaceTargetId(String appId, String namespaceName) { return STRING_JOINER.join(appId, namespaceName); } - public static String buildDefaultNamespaceTargetId(String appId){ + public static String buildDefaultNamespaceTargetId(String appId) { return STRING_JOINER.join(appId, ConfigConsts.NAMESPACE_APPLICATION); } diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/filter/ConsumerAuthenticationFilterTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/filter/ConsumerAuthenticationFilterTest.java new file mode 100644 index 0000000000000000000000000000000000000000..1ceab098c1a6317bc4195058dda2c1110a7f2083 --- /dev/null +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/filter/ConsumerAuthenticationFilterTest.java @@ -0,0 +1,71 @@ +package com.ctrip.framework.apollo.openapi.filter; + +import com.ctrip.framework.apollo.openapi.util.ConsumerAuthUtil; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; + +import javax.servlet.FilterChain; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import static org.junit.Assert.*; +import static org.mockito.Matchers.anyLong; +import static org.mockito.Matchers.anyString; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@RunWith(MockitoJUnitRunner.class) +public class ConsumerAuthenticationFilterTest { + private ConsumerAuthenticationFilter authenticationFilter; + @Mock + private ConsumerAuthUtil consumerAuthUtil; + @Mock + private HttpServletRequest request; + @Mock + private HttpServletResponse response; + @Mock + private FilterChain filterChain; + + @Before + public void setUp() throws Exception { + authenticationFilter = new ConsumerAuthenticationFilter(consumerAuthUtil); + } + + @Test + public void testAuthSuccessfully() throws Exception { + String someToken = "someToken"; + Long someConsumerId = 1L; + + when(request.getHeader("Authorization")).thenReturn(someToken); + when(consumerAuthUtil.getConsumerId(someToken)).thenReturn(someConsumerId); + + authenticationFilter.doFilter(request, response, filterChain); + + verify(consumerAuthUtil, times(1)).storeConsumerId(request, someConsumerId); + verify(filterChain, times(1)).doFilter(request, response); + } + + @Test + public void testAuthFailed() throws Exception { + String someInvalidToken = "someInvalidToken"; + + when(request.getHeader("Authorization")).thenReturn(someInvalidToken); + when(consumerAuthUtil.getConsumerId(someInvalidToken)).thenReturn(null); + + authenticationFilter.doFilter(request, response, filterChain); + + verify(response, times(1)).sendError(eq(HttpServletResponse.SC_UNAUTHORIZED), anyString()); + verify(consumerAuthUtil, never()).storeConsumerId(eq(request), anyLong()); + verify(filterChain, never()).doFilter(request, response); + } +} \ No newline at end of file diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerRolePermissionServiceTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerRolePermissionServiceTest.java new file mode 100644 index 0000000000000000000000000000000000000000..1c17512d506bc558f8076816cf7979e90e8869bf --- /dev/null +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerRolePermissionServiceTest.java @@ -0,0 +1,49 @@ +package com.ctrip.framework.apollo.openapi.service; + +import com.ctrip.framework.apollo.portal.AbstractIntegrationTest; + +import org.junit.Before; +import org.junit.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.jdbc.Sql; + +import static org.junit.Assert.*; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +public class ConsumerRolePermissionServiceTest extends AbstractIntegrationTest { + @Autowired + private ConsumerRolePermissionService consumerRolePermissionService; + + @Before + public void setUp() throws Exception { + + } + + @Test + @Sql(scripts = "/sql/permission/insert-test-roles.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD) + @Sql(scripts = "/sql/permission/insert-test-permissions.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD) + @Sql(scripts = "/sql/permission/insert-test-consumerroles.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD) + @Sql(scripts = "/sql/permission/insert-test-rolepermissions.sql", executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD) + @Sql(scripts = "/sql/cleanup.sql", executionPhase = Sql.ExecutionPhase.AFTER_TEST_METHOD) + public void testConsumerHasPermission() throws Exception { + String someTargetId = "someTargetId"; + String anotherTargetId = "anotherTargetId"; + String somePermissionType = "somePermissionType"; + String anotherPermissionType = "anotherPermissionType"; + long someConsumerId = 1; + long anotherConsumerId = 2; + long someConsumerWithNoPermission = 3; + + assertTrue(consumerRolePermissionService.consumerHasPermission(someConsumerId, somePermissionType, someTargetId)); + assertTrue(consumerRolePermissionService.consumerHasPermission(someConsumerId, anotherPermissionType, anotherTargetId)); + assertTrue(consumerRolePermissionService.consumerHasPermission(anotherConsumerId, somePermissionType, someTargetId)); + assertTrue(consumerRolePermissionService.consumerHasPermission(anotherConsumerId, anotherPermissionType, anotherTargetId)); + + assertFalse(consumerRolePermissionService.consumerHasPermission(someConsumerWithNoPermission, somePermissionType, someTargetId)); + assertFalse(consumerRolePermissionService.consumerHasPermission(someConsumerWithNoPermission, anotherPermissionType, anotherTargetId)); + + } + +} \ No newline at end of file diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerServiceTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerServiceTest.java new file mode 100644 index 0000000000000000000000000000000000000000..c9fdaefa4dbd12b7207f5de5d7f01333b67fb2f7 --- /dev/null +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/service/ConsumerServiceTest.java @@ -0,0 +1,146 @@ +package com.ctrip.framework.apollo.openapi.service; + +import com.ctrip.framework.apollo.openapi.entity.Consumer; +import com.ctrip.framework.apollo.openapi.entity.ConsumerToken; +import com.ctrip.framework.apollo.openapi.repository.ConsumerRepository; +import com.ctrip.framework.apollo.openapi.repository.ConsumerTokenRepository; +import com.ctrip.framework.apollo.portal.service.ServerConfigService; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; +import org.springframework.test.util.ReflectionTestUtils; + +import java.util.Calendar; +import java.util.Date; +import java.util.GregorianCalendar; + +import static org.junit.Assert.*; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyString; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@RunWith(MockitoJUnitRunner.class) +public class ConsumerServiceTest { + private ConsumerService consumerService; + @Mock + private ConsumerTokenRepository consumerTokenRepository; + @Mock + private ConsumerRepository consumerRepository; + @Mock + private ServerConfigService serverConfigService; + private String someTokenSalt; + + @Before + public void setUp() throws Exception { + consumerService = spy(new ConsumerService()); + ReflectionTestUtils.setField(consumerService, "consumerTokenRepository", + consumerTokenRepository); + ReflectionTestUtils.setField(consumerService, "consumerRepository", + consumerRepository); + ReflectionTestUtils.setField(consumerService, "serverConfigService", + serverConfigService); + someTokenSalt = "someTokenSalt"; + when(serverConfigService.getValue(eq(ConsumerService.TOKEN_SALT_KEY), anyString())).thenReturn(someTokenSalt); + + consumerService.afterPropertiesSet(); + } + + @Test + public void testGetConsumerId() throws Exception { + String someToken = "someToken"; + long someConsumerId = 1; + ConsumerToken someConsumerToken = new ConsumerToken(); + someConsumerToken.setConsumerId(someConsumerId); + + when(consumerTokenRepository.findTopByTokenAndExpiresAfter(eq(someToken), any(Date.class))) + .thenReturn(someConsumerToken); + + assertEquals(someConsumerId, consumerService.getConsumerIdByToken(someToken).longValue()); + } + + @Test + public void testGetConsumerIdWithNullToken() throws Exception { + Long consumerId = consumerService.getConsumerIdByToken(null); + + assertNull(consumerId); + verify(consumerTokenRepository, never()).findTopByTokenAndExpiresAfter(anyString(), any(Date + .class)); + } + + @Test + public void testGetConsumerByConsumerId() throws Exception { + long someConsumerId = 1; + Consumer someConsumer = mock(Consumer.class); + + when(consumerRepository.findOne(someConsumerId)).thenReturn(someConsumer); + + assertEquals(someConsumer, consumerService.getConsumerByConsumerId(someConsumerId)); + verify(consumerRepository, times(1)).findOne(someConsumerId); + } + + @Test + public void testCreateConsumerToken() throws Exception { + ConsumerToken someConsumerToken = mock(ConsumerToken.class); + ConsumerToken savedConsumerToken = mock(ConsumerToken.class); + + when(consumerTokenRepository.save(someConsumerToken)).thenReturn(savedConsumerToken); + + assertEquals(savedConsumerToken, consumerService.createConsumerToken(someConsumerToken)); + } + + @Test + public void testGenerateConsumerToken() throws Exception { + String someConsumerAppId = "100003171"; + Date generationTime = new GregorianCalendar(2016, Calendar.AUGUST, 9, 12, 10, 50).getTime(); + String tokenSalt = "apollo"; + + assertEquals("d0da35292dd5079eeb73cc3a5f7c0759afabd806", consumerService + .generateConsumerToken(someConsumerAppId, generationTime, tokenSalt)); + } + + @Test + public void testGenerateAndEnrichConsumerToken() throws Exception { + String someConsumerAppId = "someAppId"; + long someConsumerId = 1; + String someToken = "someToken"; + Date generationTime = new Date(); + Consumer consumer = mock(Consumer.class); + + when(consumerRepository.findOne(someConsumerId)).thenReturn(consumer); + when(consumer.getAppId()).thenReturn(someConsumerAppId); + when(consumerService.generateConsumerToken(someConsumerAppId, generationTime, someTokenSalt)) + .thenReturn(someToken); + + ConsumerToken consumerToken = new ConsumerToken(); + consumerToken.setConsumerId(someConsumerId); + consumerToken.setDataChangeCreatedTime(generationTime); + + consumerService.generateAndEnrichConsumerToken(consumerToken); + + assertEquals(someToken, consumerToken.getToken()); + } + + @Test(expected = IllegalStateException.class) + public void testGenerateAndEnrichConsumerTokenWithConsumerNotFound() throws Exception { + long someConsumerIdNotExist = 1; + + ConsumerToken consumerToken = new ConsumerToken(); + consumerToken.setConsumerId(someConsumerIdNotExist); + + when(consumerRepository.findOne(someConsumerIdNotExist)).thenReturn(null); + + consumerService.generateAndEnrichConsumerToken(consumerToken); + } +} \ No newline at end of file diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/util/ConsumerAuthUtilTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/util/ConsumerAuthUtilTest.java new file mode 100644 index 0000000000000000000000000000000000000000..a0a18773bd350028e9fe692b8129ca712892aac0 --- /dev/null +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/openapi/util/ConsumerAuthUtilTest.java @@ -0,0 +1,79 @@ +package com.ctrip.framework.apollo.openapi.util; + +import com.ctrip.framework.apollo.openapi.service.ConsumerService; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; +import org.springframework.test.util.ReflectionTestUtils; + +import javax.servlet.http.HttpServletRequest; + +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@RunWith(MockitoJUnitRunner.class) +public class ConsumerAuthUtilTest { + private ConsumerAuthUtil consumerAuthUtil; + @Mock + private ConsumerService consumerService; + @Mock + private HttpServletRequest request; + + @Before + public void setUp() throws Exception { + consumerAuthUtil = new ConsumerAuthUtil(); + ReflectionTestUtils.setField(consumerAuthUtil, "consumerService", consumerService); + } + + @Test + public void testGetConsumerId() throws Exception { + String someToken = "someToken"; + Long someConsumerId = 1L; + + when(consumerService.getConsumerIdByToken(someToken)).thenReturn(someConsumerId); + + assertEquals(someConsumerId, consumerAuthUtil.getConsumerId(someToken)); + verify(consumerService, times(1)).getConsumerIdByToken(someToken); + } + + @Test + public void testStoreConsumerId() throws Exception { + long someConsumerId = 1L; + + consumerAuthUtil.storeConsumerId(request, someConsumerId); + + verify(request, times(1)).setAttribute(ConsumerAuthUtil.CONSUMER_ID, someConsumerId); + } + + @Test + public void testRetrieveConsumerId() throws Exception { + long someConsumerId = 1; + + when(request.getAttribute(ConsumerAuthUtil.CONSUMER_ID)).thenReturn(someConsumerId); + + assertEquals(someConsumerId, consumerAuthUtil.retrieveConsumerId(request)); + verify(request, times(1)).getAttribute(ConsumerAuthUtil.CONSUMER_ID); + } + + @Test(expected = IllegalStateException.class) + public void testRetrieveConsumerIdWithConsumerIdNotSet() throws Exception { + consumerAuthUtil.retrieveConsumerId(request); + } + + @Test(expected = IllegalStateException.class) + public void testRetrieveConsumerIdWithConsumerIdInvalid() throws Exception { + String someInvalidConsumerId = "abc"; + + when(request.getAttribute(ConsumerAuthUtil.CONSUMER_ID)).thenReturn(someInvalidConsumerId); + consumerAuthUtil.retrieveConsumerId(request); + } + +} \ No newline at end of file diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/AbstractIntegrationTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/AbstractIntegrationTest.java index c2d79c596e6fef78ff954f65304af70bf79ffca4..7f1da0232325551cfdb734b8a34ed093c316b4ee 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/AbstractIntegrationTest.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/AbstractIntegrationTest.java @@ -1,6 +1,8 @@ package com.ctrip.framework.apollo.portal; +import com.ctrip.framework.apollo.PortalApplication; + import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.test.SpringApplicationConfiguration; diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/AllTests.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/AllTests.java index 1989754f1abeb9a2a3777077517c1f6dca48022b..e958071d0ee77087631f34dbab9ad5970c1d21d2 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/AllTests.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/AllTests.java @@ -1,6 +1,11 @@ package com.ctrip.framework.apollo.portal; +import com.ctrip.framework.apollo.openapi.filter.ConsumerAuthenticationFilterTest; +import com.ctrip.framework.apollo.openapi.service.ConsumerRolePermissionServiceTest; +import com.ctrip.framework.apollo.openapi.service.ConsumerServiceTest; +import com.ctrip.framework.apollo.openapi.util.ConsumerAuthUtilTest; +import com.ctrip.framework.apollo.portal.controller.ConsumerControllerTest; import com.ctrip.framework.apollo.portal.service.AppNamespaceServiceTest; import com.ctrip.framework.apollo.portal.service.ConfigServiceTest; import com.ctrip.framework.apollo.portal.service.NamespaceServiceTest; @@ -18,7 +23,9 @@ import org.junit.runners.Suite.SuiteClasses; ConfigServiceTest.class, PropertyResolverTest.class, NamespaceServiceTest.class, ServiceExceptionTest.class, RolePermissionServiceTest.class, AppNamespaceServiceTest.class, RoleInitializationServiceTest.class, FileTextResolverTest.class, - RetryableRestTemplateTest.class + RetryableRestTemplateTest.class, ConsumerRolePermissionServiceTest.class, + ConsumerAuthenticationFilterTest.class, ConsumerAuthUtilTest.class, ConsumerServiceTest.class, + ConsumerControllerTest.class }) public class AllTests { diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/ServiceExceptionTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/ServiceExceptionTest.java index 124ae18c3311e40e4a029b10b418bc41a56e3172..cd08ebe5b8a1cb01de537cfd26a0867601de9f4a 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/ServiceExceptionTest.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/ServiceExceptionTest.java @@ -11,77 +11,68 @@ import java.util.LinkedHashMap; import java.util.Map; import org.junit.Assert; -import org.junit.Before; import org.junit.Test; +import org.mockito.InjectMocks; import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; -import org.springframework.test.util.ReflectionTestUtils; import org.springframework.web.client.HttpServerErrorException; import org.springframework.web.client.HttpStatusCodeException; import com.ctrip.framework.apollo.common.entity.App; -import com.ctrip.framework.apollo.common.utils.ExceptionUtils; -import com.ctrip.framework.apollo.common.dto.AppDTO; import com.ctrip.framework.apollo.common.exception.ServiceException; import com.ctrip.framework.apollo.portal.controller.AppController; import com.ctrip.framework.apollo.portal.service.UserService; import com.google.gson.Gson; -public class ServiceExceptionTest extends AbstractIntegrationTest { +public class ServiceExceptionTest extends AbstractUnitTest { - @Autowired - private AppController appController; - @Mock - private UserService userService; + @InjectMocks + private AppController appController; + @Mock + private UserService userService; - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - ReflectionTestUtils.setField(appController, "userService", userService); - } - private String getBaseAppUrl() { - return "http://localhost:" + port + "/apps"; - } + @Test + public void testAdminServiceException() { + String errorMsg = "No available admin service"; + String errorCode = "errorCode"; + String status = "500"; - @Test - public void testAdminServiceException() { - Map errorAttributes = new LinkedHashMap<>(); - errorAttributes.put("status", 500); - errorAttributes.put("message", "No available admin service"); - errorAttributes.put("timestamp", - LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)); - errorAttributes.put("exception", ServiceException.class.getName()); - errorAttributes.put("errorCode", "8848"); + Map errorAttributes = new LinkedHashMap<>(); + errorAttributes.put("status", status); + errorAttributes.put("message", errorMsg); + errorAttributes.put("timestamp", + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME)); + errorAttributes.put("exception", ServiceException.class.getName()); + errorAttributes.put("errorCode", errorCode); - HttpStatusCodeException adminException = - new HttpServerErrorException(HttpStatus.INTERNAL_SERVER_ERROR, "admin server error", - new Gson().toJson(errorAttributes).getBytes(), Charset.defaultCharset()); + HttpStatusCodeException adminException = + new HttpServerErrorException(HttpStatus.INTERNAL_SERVER_ERROR, "admin server error", + new Gson().toJson(errorAttributes).getBytes(), Charset.defaultCharset()); - when(userService.findByUserId(any(String.class))).thenThrow(adminException); + when(userService.findByUserId(any(String.class))).thenThrow(adminException); - App app = generateSampleApp(); - try { - restTemplate.postForEntity(getBaseAppUrl(), app, AppDTO.class); - } catch (HttpStatusCodeException e) { - @SuppressWarnings("unchecked") - Map attr = new Gson().fromJson(e.getResponseBodyAsString(), Map.class); - Assert.assertEquals("500 admin server error", attr.get("message")); - Assert.assertEquals(500.0, attr.get("status")); - } - } + App app = generateSampleApp(); + try { + appController.create(app); + } catch (HttpStatusCodeException e) { + @SuppressWarnings("unchecked") + Map attr = new Gson().fromJson(e.getResponseBodyAsString(), Map.class); + Assert.assertEquals(errorMsg, attr.get("message")); + Assert.assertEquals(errorCode, attr.get("errorCode")); + Assert.assertEquals(status, attr.get("status")); + } + } - private App generateSampleApp() { - App app = new App(); - app.setAppId("someAppId"); - app.setName("someName"); - app.setOrgId("someOrgId"); - app.setOrgName("someOrgNam"); - app.setOwnerName("someOwner"); - app.setOwnerEmail("someOwner@ctrip.com"); - return app; - } + private App generateSampleApp() { + App app = new App(); + app.setAppId("someAppId"); + app.setName("someName"); + app.setOrgId("someOrgId"); + app.setOrgName("someOrgNam"); + app.setOwnerName("someOwner"); + app.setOwnerEmail("someOwner@ctrip.com"); + return app; + } } diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/controller/ConsumerControllerTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/controller/ConsumerControllerTest.java new file mode 100644 index 0000000000000000000000000000000000000000..f98d148059c1d6aefe8e08d049d81ff9fa734bc4 --- /dev/null +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/controller/ConsumerControllerTest.java @@ -0,0 +1,59 @@ +package com.ctrip.framework.apollo.portal.controller; + +import com.ctrip.framework.apollo.openapi.entity.ConsumerToken; +import com.ctrip.framework.apollo.openapi.service.ConsumerService; +import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; +import com.ctrip.framework.apollo.portal.entity.po.UserInfo; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.runners.MockitoJUnitRunner; +import org.springframework.test.util.ReflectionTestUtils; + +import java.util.Date; + +import static org.junit.Assert.*; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +/** + * @author Jason Song(song_s@ctrip.com) + */ +@RunWith(MockitoJUnitRunner.class) +public class ConsumerControllerTest { + private ConsumerController consumerController; + @Mock + private ConsumerService consumerService; + @Mock + private UserInfoHolder userInfoHolder; + + @Before + public void setUp() throws Exception { + consumerController = new ConsumerController(); + ReflectionTestUtils.setField(consumerController, "consumerService", consumerService); + ReflectionTestUtils.setField(consumerController, "userInfoHolder", userInfoHolder); + } + + @Test + public void testCreateConsumerToken() throws Exception { + UserInfo userInfo = mock(UserInfo.class); + String someUserId = "someUser"; + ConsumerToken consumerToken = mock(ConsumerToken.class); + long someConsumerId = 1; + Date someDateExpires = new Date(); + + when(userInfo.getUserId()).thenReturn(someUserId); + when(userInfoHolder.getUser()).thenReturn(userInfo); + when(consumerService.createConsumerToken(any(ConsumerToken.class))).thenReturn(consumerToken); + + assertEquals(consumerToken, consumerController.createConsumerToken(someConsumerId, someDateExpires)); + verify(consumerService, times(1)).generateAndEnrichConsumerToken(any(ConsumerToken.class)); + verify(consumerService, times(1)).createConsumerToken(any(ConsumerToken.class)); + } + +} \ No newline at end of file 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 042b0cd33ac1a45fba119ede93be6851a49f3e9e..19c767f4c470d82eefe193e57354670340507d29 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 @@ -10,7 +10,7 @@ import com.ctrip.framework.apollo.portal.api.AdminServiceAPI; import com.ctrip.framework.apollo.portal.auth.UserInfoHolder; import com.ctrip.framework.apollo.portal.entity.po.UserInfo; import com.ctrip.framework.apollo.portal.entity.vo.ItemDiffs; -import com.ctrip.framework.apollo.portal.entity.vo.NamespaceIdentifer; +import com.ctrip.framework.apollo.portal.entity.vo.NamespaceIdentifier; import com.ctrip.framework.apollo.portal.entity.form.NamespaceTextModel; import com.ctrip.framework.apollo.portal.service.txtresolver.PropertyResolver; @@ -44,7 +44,7 @@ public class ConfigServiceTest { private UserInfoHolder userInfoHolder; @InjectMocks - private ConfigService configService; + private ItemService configService; @Before public void setup() { @@ -100,7 +100,7 @@ public class ConfigServiceTest { String appId = "6666", env = "LOCAL", clusterName = ConfigConsts.CLUSTER_NAME_DEFAULT, namespaceName = ConfigConsts.NAMESPACE_APPLICATION; - List namespaceIdentifers = generateNamespaceIdentifer(appId, env, clusterName, namespaceName); + List namespaceIdentifiers = generateNamespaceIdentifer(appId, env, clusterName, namespaceName); NamespaceDTO namespaceDTO = generateNamespaceDTO(appId, clusterName, namespaceName); when(namespaceAPI.loadNamespace(appId, Env.valueOf(env), clusterName, namespaceName)).thenReturn(namespaceDTO); @@ -110,7 +110,7 @@ public class ConfigServiceTest { userInfo.setUserId("test"); when(userInfoHolder.getUser()).thenReturn(userInfo); - List itemDiffses = configService.compare(namespaceIdentifers, sourceItems); + List itemDiffses = configService.compare(namespaceIdentifiers, sourceItems); assertEquals(1,itemDiffses.size()); ItemDiffs itemDiffs = itemDiffses.get(0); @@ -141,7 +141,7 @@ public class ConfigServiceTest { String appId = "6666", env = "LOCAL", clusterName = ConfigConsts.CLUSTER_NAME_DEFAULT, namespaceName = ConfigConsts.NAMESPACE_APPLICATION; - List namespaceIdentifers = generateNamespaceIdentifer(appId, env, clusterName, namespaceName); + List namespaceIdentifiers = generateNamespaceIdentifer(appId, env, clusterName, namespaceName); NamespaceDTO namespaceDTO = generateNamespaceDTO(appId, clusterName, namespaceName); when(namespaceAPI.loadNamespace(appId, Env.valueOf(env), clusterName, namespaceName)).thenReturn(namespaceDTO); @@ -151,7 +151,7 @@ public class ConfigServiceTest { userInfo.setUserId("test"); when(userInfoHolder.getUser()).thenReturn(userInfo); - List itemDiffses = configService.compare(namespaceIdentifers, sourceItems); + List itemDiffses = configService.compare(namespaceIdentifiers, sourceItems); assertEquals(1, itemDiffses.size()); ItemDiffs itemDiffs = itemDiffses.get(0); @@ -161,11 +161,11 @@ public class ConfigServiceTest { assertEquals(2, changeSets.getUpdateItems().size()); assertEquals(1, changeSets.getCreateItems().size()); - NamespaceIdentifer namespaceIdentifer = itemDiffs.getNamespace(); - assertEquals(appId, namespaceIdentifer.getAppId()); - assertEquals(Env.valueOf("LOCAL"), namespaceIdentifer.getEnv()); - assertEquals(clusterName, namespaceIdentifer.getClusterName()); - assertEquals(namespaceName, namespaceIdentifer.getNamespaceName()); + NamespaceIdentifier namespaceIdentifier = itemDiffs.getNamespace(); + assertEquals(appId, namespaceIdentifier.getAppId()); + assertEquals(Env.valueOf("LOCAL"), namespaceIdentifier.getEnv()); + assertEquals(clusterName, namespaceIdentifier.getClusterName()); + assertEquals(namespaceName, namespaceIdentifier.getNamespaceName()); ItemDTO createdItem = changeSets.getCreateItems().get(0); assertEquals("newKey", createdItem.getKey()); @@ -198,8 +198,8 @@ public class ConfigServiceTest { return namespaceDTO; } - private List generateNamespaceIdentifer(String appId, String env, String clusterName, String namespaceName){ - NamespaceIdentifer targetNamespace = new NamespaceIdentifer(); + private List generateNamespaceIdentifer(String appId, String env, String clusterName, String namespaceName){ + NamespaceIdentifier targetNamespace = new NamespaceIdentifier(); targetNamespace.setAppId(appId); targetNamespace.setEnv(env); targetNamespace.setClusterName(clusterName); diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/NamespaceServiceTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/NamespaceServiceTest.java index af807e243cfe7600f7d726acac6d4c0b82362ca3..debf77c8b52855f134083261460262c21f13f75c 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/NamespaceServiceTest.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/NamespaceServiceTest.java @@ -30,9 +30,9 @@ public class NamespaceServiceTest { @Mock private AdminServiceAPI.NamespaceAPI namespaceAPI; @Mock - private AdminServiceAPI.ReleaseAPI releaseAPI; + private ReleaseService releaseService; @Mock - private AdminServiceAPI.ItemAPI itemAPI; + private ItemService itemService; @Mock private PropertyResolver resolver; @Mock @@ -82,9 +82,9 @@ public class NamespaceServiceTest { .thenReturn(applicationAppNamespace); when(appNamespaceService.findPublicAppNamespace("hermes")).thenReturn(hermesAppNamespace); when(namespaceAPI.findNamespaceByCluster(appId, Env.DEV, clusterName)).thenReturn(namespaces); - when(releaseAPI.loadLatestRelease(appId, Env.DEV, clusterName, namespaceName)).thenReturn(someRelease); - when(releaseAPI.loadLatestRelease(appId, Env.DEV, clusterName, "hermes")).thenReturn(someRelease); - when(itemAPI.findItems(appId, Env.DEV, clusterName, namespaceName)).thenReturn(someItems); + when(releaseService.loadLatestRelease(appId, Env.DEV, clusterName, namespaceName)).thenReturn(someRelease); + when(releaseService.loadLatestRelease(appId, Env.DEV, clusterName, "hermes")).thenReturn(someRelease); + when(itemService.findItems(appId, Env.DEV, clusterName, namespaceName)).thenReturn(someItems); List namespaceVOs = namespaceService.findNamespaces(appId, Env.DEV, clusterName); assertEquals(2, namespaceVOs.size()); diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/RoleInitializationServiceTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/RoleInitializationServiceTest.java index 053fa1249ebbe17a87a00f9a43c84a3c0f548093..935e1d950ebe5ae3f68d838976d834e2d3f9f196 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/RoleInitializationServiceTest.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/service/RoleInitializationServiceTest.java @@ -17,6 +17,7 @@ import org.mockito.Mock; import static org.mockito.Matchers.any; import static org.mockito.Matchers.anySet; +import static org.mockito.Matchers.anySetOf; import static org.mockito.Matchers.anyString; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; @@ -46,7 +47,7 @@ public class RoleInitializationServiceTest extends AbstractUnitTest { roleInitializationService.initAppRoles(mockApp()); verify(rolePermissionService, times(1)).findRoleByRoleName(RoleUtils.buildAppMasterRoleName(APP_ID)); - verify(rolePermissionService, times(0)).assignRoleToUsers(anyString(), anySet(), anyString()); + verify(rolePermissionService, times(0)).assignRoleToUsers(anyString(), anySetOf(String.class), anyString()); } @Test @@ -62,7 +63,7 @@ public class RoleInitializationServiceTest extends AbstractUnitTest { verify(rolePermissionService, times(1)).assignRoleToUsers( RoleUtils.buildAppMasterRoleName(APP_ID), Sets.newHashSet(CURRENT_USER), CURRENT_USER); verify(rolePermissionService, times(2)).createPermission(any()); - verify(rolePermissionService, times(3)).createRoleWithPermissions(any(), anySet()); + verify(rolePermissionService, times(3)).createRoleWithPermissions(any(), anySetOf(Long.class)); } @Test @@ -80,7 +81,7 @@ public class RoleInitializationServiceTest extends AbstractUnitTest { verify(rolePermissionService, times(2)).findRoleByRoleName(anyString()); verify(rolePermissionService, times(0)).createPermission(any()); - verify(rolePermissionService, times(0)).createRoleWithPermissions(any(), anySet()); + verify(rolePermissionService, times(0)).createRoleWithPermissions(any(), anySetOf(Long.class)); } @Test @@ -101,7 +102,7 @@ public class RoleInitializationServiceTest extends AbstractUnitTest { verify(rolePermissionService, times(2)).findRoleByRoleName(anyString()); verify(rolePermissionService, times(2)).createPermission(any()); - verify(rolePermissionService, times(2)).createRoleWithPermissions(any(), anySet()); + verify(rolePermissionService, times(2)).createRoleWithPermissions(any(), anySetOf(Long.class)); } @Test @@ -122,7 +123,7 @@ public class RoleInitializationServiceTest extends AbstractUnitTest { verify(rolePermissionService, times(2)).findRoleByRoleName(anyString()); verify(rolePermissionService, times(1)).createPermission(any()); - verify(rolePermissionService, times(1)).createRoleWithPermissions(any(), anySet()); + verify(rolePermissionService, times(1)).createRoleWithPermissions(any(), anySetOf(Long.class)); } private App mockApp(){ diff --git a/apollo-portal/src/test/resources/sql/permission/insert-test-consumerroles.sql b/apollo-portal/src/test/resources/sql/permission/insert-test-consumerroles.sql new file mode 100644 index 0000000000000000000000000000000000000000..e52e28438392f4877f3226054b9fbdf556599dea --- /dev/null +++ b/apollo-portal/src/test/resources/sql/permission/insert-test-consumerroles.sql @@ -0,0 +1,4 @@ +INSERT INTO `consumerrole` (`Id`, `ConsumerId`, `RoleId`, `DataChange_CreatedBy`, `DataChange_LastModifiedBy`) + VALUES (890, 1, 990, 'someOperator', 'someOperator'); +INSERT INTO `consumerrole` (`Id`, `ConsumerId`, `RoleId`, `DataChange_CreatedBy`, `DataChange_LastModifiedBy`) + VALUES (891, 2, 990, 'someOperator', 'someOperator'); diff --git a/pom.xml b/pom.xml index 701fabc7f3cd3607772812b6a29da4e1ca05ca5d..d2d363a918499998f5a0d1be5f3964d59c71693b 100644 --- a/pom.xml +++ b/pom.xml @@ -179,7 +179,7 @@ com.ctrip.framework.apollo-sso apollo-sso-ctrip - 1.0.0 + 1.1.0