add ruleType property for AbstractDataSourceProperties and fixes #206

spring-cloud-alibaba-sentinel-datasource/src/main/java/org/springframework/cloud/alibaba/sentinel/datasource/RuleType.java

@@ -0,0 +1,81 @@
+package org.springframework.cloud.alibaba.sentinel.datasource;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+import org.springframework.cloud.alibaba.sentinel.datasource.config.AbstractDataSourceProperties;
+import org.springframework.util.StringUtils;
+
+import com.alibaba.csp.sentinel.slots.block.AbstractRule;
+import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
+import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
+import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
+import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
+import com.alibaba.csp.sentinel.slots.system.SystemRule;
+
+/**
+ * Enum for {@link AbstractRule} class, using in
+ * {@link AbstractDataSourceProperties#ruleType}
+ *
+ * @author <a href="mailto:fangjian0423@gmail.com">Jim</a>
+ */
+public enum RuleType {
+
+	/**
+	 * flow
+	 */
+	FLOW("flow", FlowRule.class),
+	/**
+	 * degrade
+	 */
+	DEGRADE("degrade", DegradeRule.class),
+	/**
+	 * param flow
+	 */
+	PARAM_FLOW("param-flow", ParamFlowRule.class),
+	/**
+	 * system
+	 */
+	SYSTEM("system", SystemRule.class),
+	/**
+	 * authority
+	 */
+	AUTHORITY("authority", AuthorityRule.class);
+
+	/**
+	 * alias for {@link AbstractRule}
+	 */
+	private final String name;
+
+	/**
+	 * concrete {@link AbstractRule} class
+	 */
+	private final Class clazz;
+
+	RuleType(String name, Class clazz) {
+		this.name = name;
+		this.clazz = clazz;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public Class getClazz() {
+		return clazz;
+	}
+
+	public static Optional<RuleType> getByName(String name) {
+		if (StringUtils.isEmpty(name)) {
+			return Optional.empty();
+		}
+		return Arrays.stream(RuleType.values())
+				.filter(ruleType -> name.equals(ruleType.getName())).findFirst();
+	}
+
+	public static Optional<RuleType> getByClass(Class clazz) {
+		return Arrays.stream(RuleType.values())
+				.filter(ruleType -> clazz == ruleType.getClazz()).findFirst();
+	}
+
+}

spring-cloud-alibaba-sentinel-datasource/src/main/java/org/springframework/cloud/alibaba/sentinel/datasource/config/AbstractDataSourceProperties.java

@@ -1,5 +1,14 @@
 package org.springframework.cloud.alibaba.sentinel.datasource.config;
 
+import org.springframework.cloud.alibaba.sentinel.datasource.RuleType;
+
+import com.alibaba.csp.sentinel.datasource.AbstractDataSource;
+import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleManager;
+import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
+import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
+import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
+import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
+
 import com.fasterxml.jackson.annotation.JsonIgnore;
 
 /**
@@ -10,6 +19,7 @@ import com.fasterxml.jackson.annotation.JsonIgnore;
 public class AbstractDataSourceProperties {
 
 	private String dataType = "json";
+	private String ruleType;
 	private String converterClass;
 	@JsonIgnore
 	protected String factoryBeanName;
@@ -26,6 +36,14 @@ public class AbstractDataSourceProperties {
 		this.dataType = dataType;
 	}
 
+	public String getRuleType() {
+		return ruleType;
+	}
+
+	public void setRuleType(String ruleType) {
+		this.ruleType = ruleType;
+	}
+
 	public String getConverterClass() {
 		return converterClass;
 	}
@@ -42,8 +60,33 @@ public class AbstractDataSourceProperties {
 		this.factoryBeanName = factoryBeanName;
 	}
 
-	public void preCheck() {
-
+	public void preCheck(String dataSourceName) {
+		if (!RuleType.getByName(this.getRuleType()).isPresent()) {
+			throw new IllegalArgumentException(
+					"[Sentinel Starter] DataSource " + dataSourceName
+							+ " get error ruleType [" + this.getRuleType() + "]");
+		}
 	}
 
+	public void postRegister(AbstractDataSource dataSource) {
+		switch (RuleType.getByName(this.getRuleType()).get()) {
+		case FLOW:
+			FlowRuleManager.register2Property(dataSource.getProperty());
+			break;
+		case DEGRADE:
+			DegradeRuleManager.register2Property(dataSource.getProperty());
+			break;
+		case PARAM_FLOW:
+			ParamFlowRuleManager.register2Property(dataSource.getProperty());
+			break;
+		case SYSTEM:
+			SystemRuleManager.register2Property(dataSource.getProperty());
+			break;
+		case AUTHORITY:
+			AuthorityRuleManager.register2Property(dataSource.getProperty());
+			break;
+		default:
+			break;
+		}
+	}
 }

spring-cloud-alibaba-sentinel-datasource/src/main/java/org/springframework/cloud/alibaba/sentinel/datasource/config/FileDataSourceProperties.java

@@ -56,16 +56,17 @@ public class FileDataSourceProperties extends AbstractDataSourceProperties {
 	}
 
 	@Override
-	public void preCheck() {
-		super.preCheck();
+	public void preCheck(String dataSourceName) {
+		super.preCheck(dataSourceName);
 		try {
 			this.setFile(
 					ResourceUtils.getFile(StringUtils.trimAllWhitespace(this.getFile()))
 							.getAbsolutePath());
 		}
 		catch (IOException e) {
-			throw new RuntimeException("[Sentinel Starter] " + " handle file ["
-					+ this.getFile() + "] error: " + e.getMessage(), e);
+			throw new RuntimeException("[Sentinel Starter] DataSource " + dataSourceName
+					+ " handle file [" + this.getFile() + "] error: " + e.getMessage(),
+					e);
 		}
 
 	}

spring-cloud-alibaba-sentinel-datasource/src/main/java/org/springframework/cloud/alibaba/sentinel/datasource/config/NacosDataSourceProperties.java

@@ -1,5 +1,6 @@
 package org.springframework.cloud.alibaba.sentinel.datasource.config;
 
+import org.springframework.cloud.alibaba.sentinel.datasource.RuleType;
 import org.springframework.cloud.alibaba.sentinel.datasource.SentinelDataSourceConstants;
 import org.springframework.cloud.alibaba.sentinel.datasource.factorybean.NacosDataSourceFactoryBean;
 import org.springframework.cloud.alibaba.sentinel.datasource.factorybean.NacosDataSourceWithAuthorizationFactoryBean;
@@ -29,7 +30,7 @@ public class NacosDataSourceProperties extends AbstractDataSourceProperties {
 	}
 
 	@Override
-	public void preCheck() {
+	public void preCheck(String dataSourceName) {
 		if (!StringUtils.isEmpty(System.getProperties()
 				.getProperty(SentinelDataSourceConstants.NACOS_DATASOURCE_ENDPOINT))) {
 			this.setServerAddr(null);
@@ -126,6 +127,12 @@ public class NacosDataSourceProperties extends AbstractDataSourceProperties {
 		result.setDataId(System.getProperties()
 				.getProperty(SentinelDataSourceConstants.PROJECT_NAME) + "-" + type);
 		result.setGroupId("nacos-sentinel");
+		if (type.equals(RuleType.FLOW.getName())) {
+			result.setRuleType(RuleType.FLOW.getName());
+		}
+		else {
+			result.setRuleType(RuleType.DEGRADE.getName());
+		}
 		return result;
 	}
 }

spring-cloud-alibaba-sentinel-datasource/src/main/java/org/springframework/cloud/alibaba/sentinel/datasource/converter/JsonConverter.java

@@ -1,28 +1,11 @@
 package org.springframework.cloud.alibaba.sentinel.datasource.converter;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.util.ObjectUtils;
-import org.springframework.util.StringUtils;
-
-import com.alibaba.csp.sentinel.datasource.Converter;
-import com.alibaba.csp.sentinel.slots.block.AbstractRule;
 import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
 import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
-import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
 import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
-import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleUtil;
 import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
 import com.alibaba.csp.sentinel.slots.system.SystemRule;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 /**
@@ -36,133 +19,10 @@ import com.fasterxml.jackson.databind.ObjectMapper;
  * @see ParamFlowRule
  * @see ObjectMapper
  */
-public class JsonConverter implements Converter<String, List<AbstractRule>> {
+public class JsonConverter<T> extends SentinelConverter {
 
-	private static final Logger logger = LoggerFactory.getLogger(JsonConverter.class);
-
-	private final ObjectMapper objectMapper;
-
-	public JsonConverter(ObjectMapper objectMapper) {
-		this.objectMapper = objectMapper;
-	}
-
-	@Override
-	public List<AbstractRule> convert(String source) {
-		List<AbstractRule> ruleList = new ArrayList<>();
-		if (StringUtils.isEmpty(source)) {
-			logger.warn(
-					"Sentinel JsonConverter can not convert rules because source is empty");
-			return ruleList;
-		}
-		try {
-			List jsonArray = objectMapper.readValue(source,
-					new TypeReference<List<HashMap>>() {
-					});
-			jsonArray.stream().forEach(obj -> {
-
-				String itemJson = null;
-				try {
-					itemJson = objectMapper.writeValueAsString(obj);
-				}
-				catch (JsonProcessingException e) {
-					// won't be happen
-				}
-
-				List<AbstractRule> rules = Arrays.asList(convertFlowRule(itemJson),
-						convertDegradeRule(itemJson), convertSystemRule(itemJson),
-						convertAuthorityRule(itemJson), convertParamFlowRule(itemJson));
-
-				List<AbstractRule> convertRuleList = rules.stream()
-						.filter(rule -> !ObjectUtils.isEmpty(rule))
-						.collect(Collectors.toList());
-
-				if (convertRuleList.size() == 0) {
-					logger.warn(
-							"Sentinel JsonConverter can not convert {} to any rules, ignore",
-							itemJson);
-				}
-				else if (convertRuleList.size() > 1) {
-					logger.warn(
-							"Sentinel JsonConverter convert {} and match multi rules, ignore",
-							itemJson);
-				}
-				else {
-					ruleList.add(convertRuleList.get(0));
-				}
-
-			});
-			if (jsonArray.size() != ruleList.size()) {
-				logger.warn(
-						"Sentinel JsonConverter Source list size is not equals to Target List, maybe a "
-								+ "part of json is invalid. Source List: " + jsonArray
-								+ ", Target List: " + ruleList);
-			}
-		}
-		catch (Exception e) {
-			logger.error("Sentinel JsonConverter convert error: " + e.getMessage());
-			throw new RuntimeException(
-					"Sentinel JsonConverter convert error: " + e.getMessage(), e);
-		}
-		return ruleList;
-	}
-
-	private FlowRule convertFlowRule(String json) {
-		try {
-			FlowRule rule = objectMapper.readValue(json, FlowRule.class);
-			if (FlowRuleUtil.isValidRule(rule)) {
-				return rule;
-			}
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return null;
-	}
-
-	private DegradeRule convertDegradeRule(String json) {
-		try {
-			DegradeRule rule = objectMapper.readValue(json, DegradeRule.class);
-			if (DegradeRuleManager.isValidRule(rule)) {
-				return rule;
-			}
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return null;
-	}
-
-	private SystemRule convertSystemRule(String json) {
-		SystemRule rule = null;
-		try {
-			rule = objectMapper.readValue(json, SystemRule.class);
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return rule;
-	}
-
-	private AuthorityRule convertAuthorityRule(String json) {
-		AuthorityRule rule = null;
-		try {
-			rule = objectMapper.readValue(json, AuthorityRule.class);
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return rule;
-	}
-
-	private ParamFlowRule convertParamFlowRule(String json) {
-		ParamFlowRule rule = null;
-		try {
-			rule = objectMapper.readValue(json, ParamFlowRule.class);
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return rule;
+	public JsonConverter(ObjectMapper objectMapper, Class<T> ruleClass) {
+		super(objectMapper, ruleClass);
 	}
 
 }

spring-cloud-alibaba-sentinel-datasource/src/main/java/org/springframework/cloud/alibaba/sentinel/datasource/converter/SentinelConverter.java

@@ -0,0 +1,115 @@
+package org.springframework.cloud.alibaba.sentinel.datasource.converter;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Optional;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.cloud.alibaba.sentinel.datasource.RuleType;
+import org.springframework.util.StringUtils;
+
+import com.alibaba.csp.sentinel.datasource.Converter;
+import com.alibaba.csp.sentinel.slots.block.AbstractRule;
+import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
+import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
+import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
+import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
+import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleUtil;
+import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
+import com.alibaba.csp.sentinel.slots.system.SystemRule;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+/**
+ * Convert sentinel rules for json or xml array Using strict mode to parse json or xml
+ *
+ * @author <a href="mailto:fangjian0423@gmail.com">Jim</a>
+ * @see FlowRule
+ * @see DegradeRule
+ * @see SystemRule
+ * @see AuthorityRule
+ * @see ParamFlowRule
+ * @see ObjectMapper
+ */
+public abstract class SentinelConverter<T extends AbstractRule>
+		implements Converter<String, List<AbstractRule>> {
+
+	private static final Logger logger = LoggerFactory.getLogger(SentinelConverter.class);
+
+	private final ObjectMapper objectMapper;
+
+	private final Class<T> ruleClass;
+
+	public SentinelConverter(ObjectMapper objectMapper, Class<T> ruleClass) {
+		this.objectMapper = objectMapper;
+		this.ruleClass = ruleClass;
+	}
+
+	@Override
+	public List<AbstractRule> convert(String source) {
+		List<AbstractRule> ruleList = new ArrayList<>();
+		if (StringUtils.isEmpty(source)) {
+			logger.warn("converter can not convert rules because source is empty");
+			return ruleList;
+		}
+		try {
+			List sourceArray = objectMapper.readValue(source,
+					new TypeReference<List<HashMap>>() {
+					});
+			sourceArray.stream().forEach(obj -> {
+
+				String item = null;
+				try {
+					item = objectMapper.writeValueAsString(obj);
+				}
+				catch (JsonProcessingException e) {
+					// won't be happen
+				}
+
+				Optional.ofNullable(convertRule(item))
+						.ifPresent(convertRule -> ruleList.add(convertRule));
+			});
+
+			if (ruleList.size() != sourceArray.size()) {
+				throw new IllegalArgumentException("convert " + ruleList.size()
+						+ " rules but there are " + sourceArray.size()
+						+ " rules from datasource. RuleClass: "
+						+ ruleClass.getSimpleName());
+			}
+		}
+		catch (Exception e) {
+			throw new RuntimeException("convert error: " + e.getMessage(), e);
+		}
+		return ruleList;
+	}
+
+	private AbstractRule convertRule(String ruleStr) {
+		try {
+			final AbstractRule rule = objectMapper.readValue(ruleStr, ruleClass);
+			RuleType ruleType = RuleType.getByClass(ruleClass).get();
+			switch (ruleType) {
+			case FLOW:
+				if (!FlowRuleUtil.isValidRule((FlowRule) rule)) {
+					return null;
+				}
+				break;
+			case DEGRADE:
+				if (!DegradeRuleManager.isValidRule((DegradeRule) rule)) {
+					return null;
+				}
+			default:
+				break;
+			}
+			return rule;
+		}
+		catch (Exception e) {
+			// ignore
+		}
+		return null;
+	}
+
+}

spring-cloud-alibaba-sentinel-datasource/src/main/java/org/springframework/cloud/alibaba/sentinel/datasource/converter/XmlConverter.java

@@ -1,28 +1,12 @@
 package org.springframework.cloud.alibaba.sentinel.datasource.converter;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.util.ObjectUtils;
-import org.springframework.util.StringUtils;
-
-import com.alibaba.csp.sentinel.datasource.Converter;
-import com.alibaba.csp.sentinel.slots.block.AbstractRule;
 import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
 import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
-import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
 import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
-import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleUtil;
 import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
 import com.alibaba.csp.sentinel.slots.system.SystemRule;
 
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.dataformat.xml.XmlMapper;
 
 /**
@@ -34,134 +18,12 @@ import com.fasterxml.jackson.dataformat.xml.XmlMapper;
  * @see SystemRule
  * @see AuthorityRule
  * @see ParamFlowRule
+ * @see ObjectMapper
  */
-public class XmlConverter implements Converter<String, List<AbstractRule>> {
+public class XmlConverter<T> extends SentinelConverter {
 
-	private static final Logger logger = LoggerFactory.getLogger(XmlConverter.class);
-
-	private final XmlMapper xmlMapper;
-
-	public XmlConverter(XmlMapper xmlMapper) {
-		this.xmlMapper = xmlMapper;
-	}
-
-	@Override
-	public List<AbstractRule> convert(String source) {
-		List<AbstractRule> ruleList = new ArrayList<>();
-		if (StringUtils.isEmpty(source)) {
-			logger.warn(
-					"Sentinel XmlConverter can not convert rules because source is empty");
-			return ruleList;
-		}
-		try {
-			List xmlArray = xmlMapper.readValue(source,
-					new TypeReference<List<HashMap>>() {
-					});
-			xmlArray.stream().forEach(obj -> {
-
-				String itemXml = null;
-				try {
-					itemXml = xmlMapper.writeValueAsString(obj);
-				}
-				catch (JsonProcessingException e) {
-					// won't be happen
-				}
-
-				List<AbstractRule> rules = Arrays.asList(convertFlowRule(itemXml),
-						convertDegradeRule(itemXml), convertSystemRule(itemXml),
-						convertAuthorityRule(itemXml), convertParamFlowRule(itemXml));
-
-				List<AbstractRule> convertRuleList = rules.stream()
-						.filter(rule -> !ObjectUtils.isEmpty(rule))
-						.collect(Collectors.toList());
-
-				if (convertRuleList.size() == 0) {
-					logger.warn(
-							"Sentinel XmlConverter can not convert {} to any rules, ignore",
-							itemXml);
-				}
-				else if (convertRuleList.size() > 1) {
-					logger.warn(
-							"Sentinel XmlConverter convert {} and match multi rules, ignore",
-							itemXml);
-				}
-				else {
-					ruleList.add(convertRuleList.get(0));
-				}
-
-			});
-			if (xmlArray.size() != ruleList.size()) {
-				logger.warn(
-						"Sentinel XmlConverter Source list size is not equals to Target List, maybe a "
-								+ "part of xml is invalid. Source List: " + xmlArray
-								+ ", Target List: " + ruleList);
-			}
-		}
-		catch (Exception e) {
-			logger.error("Sentinel XmlConverter convert error: " + e.getMessage());
-			throw new RuntimeException(
-					"Sentinel XmlConverter convert error: " + e.getMessage(), e);
-		}
-		return ruleList;
-	}
-
-	private FlowRule convertFlowRule(String xml) {
-		try {
-			FlowRule rule = xmlMapper.readValue(xml, FlowRule.class);
-			if (FlowRuleUtil.isValidRule(rule)) {
-				return rule;
-			}
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return null;
-	}
-
-	private DegradeRule convertDegradeRule(String xml) {
-		try {
-			DegradeRule rule = xmlMapper.readValue(xml, DegradeRule.class);
-			if (DegradeRuleManager.isValidRule(rule)) {
-				return rule;
-			}
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return null;
-	}
-
-	private SystemRule convertSystemRule(String xml) {
-		SystemRule rule = null;
-		try {
-			rule = xmlMapper.readValue(xml, SystemRule.class);
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return rule;
-	}
-
-	private AuthorityRule convertAuthorityRule(String xml) {
-		AuthorityRule rule = null;
-		try {
-			rule = xmlMapper.readValue(xml, AuthorityRule.class);
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return rule;
-	}
-
-	private ParamFlowRule convertParamFlowRule(String json) {
-		ParamFlowRule rule = null;
-		try {
-			rule = xmlMapper.readValue(json, ParamFlowRule.class);
-		}
-		catch (Exception e) {
-			// ignore
-		}
-		return rule;
+	public XmlConverter(XmlMapper xmlMapper, Class<T> ruleClass) {
+		super(xmlMapper, ruleClass);
 	}
 
 }