com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule Java Examples

@Before
public void setUp() {
	FlowRule rule = new FlowRule();
	rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
	rule.setCount(0);
	rule.setResource("GET:" + flowUrl);
	rule.setLimitApp("default");
	rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
	rule.setStrategy(RuleConstant.STRATEGY_DIRECT);
	FlowRuleManager.loadRules(Arrays.asList(rule));

	DegradeRule degradeRule = new DegradeRule();
	degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
	degradeRule.setResource("GET:" + degradeUrl);
	degradeRule.setCount(0);
	degradeRule.setTimeWindow(60);
	DegradeRuleManager.loadRules(Arrays.asList(degradeRule));
}
 

private void listenRules() throws Exception {
    ClassLoader classLoader = getClass().getClassLoader();
    String flowRulePath = URLDecoder.decode(classLoader.getResource("FlowRule.json").getFile(), "UTF-8");
    String degradeRulePath = URLDecoder.decode(classLoader.getResource("DegradeRule.json").getFile(), "UTF-8");
    String systemRulePath = URLDecoder.decode(classLoader.getResource("SystemRule.json").getFile(), "UTF-8");

    // Data source for FlowRule
    FileRefreshableDataSource<List<FlowRule>> flowRuleDataSource = new FileRefreshableDataSource<>(
        flowRulePath, flowRuleListParser);
    FlowRuleManager.register2Property(flowRuleDataSource.getProperty());

    // Data source for DegradeRule
    FileRefreshableDataSource<List<DegradeRule>> degradeRuleDataSource
        = new FileRefreshableDataSource<>(
        degradeRulePath, degradeRuleListParser);
    DegradeRuleManager.register2Property(degradeRuleDataSource.getProperty());

    // Data source for SystemRule
    FileRefreshableDataSource<List<SystemRule>> systemRuleDataSource
        = new FileRefreshableDataSource<>(
        systemRulePath, systemRuleListParser);
    SystemRuleManager.register2Property(systemRuleDataSource.getProperty());
}
 

private static void initDegradeRule() {
    List<DegradeRule> rules = new ArrayList<DegradeRule>();
    DegradeRule rule = new DegradeRule();
    rule.setResource(KEY);
    // set limit exception count to 4
    rule.setCount(4);
    rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
    /**
     * When degrading by {@link RuleConstant#DEGRADE_GRADE_EXCEPTION_COUNT}, time window
     * less than 60 seconds will not work as expected. Because the exception count is
     * summed by minute, when a short time window elapsed, the degradation condition
     * may still be satisfied.
     */
    rule.setTimeWindow(10);
    rules.add(rule);
    DegradeRuleManager.loadRules(rules);
}
 

@Test
public void testCreateDirectlyThenRun() {
	// Create a circuit breaker without any circuit breaking rules.
	CircuitBreaker cb = new SentinelCircuitBreaker(
			"testSentinelCreateDirectlyThenRunA");
	assertThat(cb.run(() -> "Sentinel")).isEqualTo("Sentinel");
	assertThat(DegradeRuleManager.hasConfig("testSentinelCreateDirectlyThenRunA"))
			.isFalse();

	CircuitBreaker cb2 = new SentinelCircuitBreaker(
			"testSentinelCreateDirectlyThenRunB",
			Collections.singletonList(
					new DegradeRule("testSentinelCreateDirectlyThenRunB")
							.setCount(100).setTimeWindow(10)));
	assertThat(cb2.run(() -> "Sentinel")).isEqualTo("Sentinel");
	assertThat(DegradeRuleManager.hasConfig("testSentinelCreateDirectlyThenRunB"))
			.isTrue();
}
 

@Bean
public Customizer<ReactiveSentinelCircuitBreakerFactory> slowCustomizer() {
	return factory -> {
		factory.configure(builder -> builder
				.rules(Collections.singletonList(new DegradeRule("slow_mono")
						.setGrade(RuleConstant.DEGRADE_GRADE_RT).setCount(100)
						.setTimeWindow(5))),
				"slow_mono");
		factory.configure(builder -> builder
				.rules(Collections.singletonList(new DegradeRule("slow_flux")
						.setGrade(RuleConstant.DEGRADE_GRADE_RT).setCount(100)
						.setTimeWindow(5))),
				"slow_flux");
		factory.configureDefault(id -> new SentinelConfigBuilder()
				.resourceName(id)
				.rules(Collections.singletonList(new DegradeRule(id)
						.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT)
						.setCount(0.5).setTimeWindow(10)))
				.build());
	};
}
 

@Bean
public Customizer<SentinelCircuitBreakerFactory> slowCustomizer() {
	String slowId = "slow";
	List<DegradeRule> rules = Collections.singletonList(
			new DegradeRule(slowId).setGrade(RuleConstant.DEGRADE_GRADE_RT)
					.setCount(100).setTimeWindow(10));
	return factory -> {
		factory.configure(builder -> builder.rules(rules), slowId);
		factory.configureDefault(id -> new SentinelConfigBuilder()
				.resourceName(id)
				.rules(Collections.singletonList(new DegradeRule(id)
						.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT)
						.setCount(0.5).setTimeWindow(10)))
				.build());
	};
}
 

/**
 * register fastjson serializer deserializer class info
 */
public void init() {
    SerializeConfig.getGlobalInstance().getObjectWriter(NodeVo.class);
    SerializeConfig.getGlobalInstance().getObjectWriter(FlowRule.class);
    SerializeConfig.getGlobalInstance().getObjectWriter(SystemRule.class);
    SerializeConfig.getGlobalInstance().getObjectWriter(DegradeRule.class);
    SerializeConfig.getGlobalInstance().getObjectWriter(AuthorityRule.class);
    SerializeConfig.getGlobalInstance().getObjectWriter(ParamFlowRule.class);

    ParserConfig.getGlobalInstance().getDeserializer(NodeVo.class);
    ParserConfig.getGlobalInstance().getDeserializer(FlowRule.class);
    ParserConfig.getGlobalInstance().getDeserializer(SystemRule.class);
    ParserConfig.getGlobalInstance().getDeserializer(DegradeRule.class);
    ParserConfig.getGlobalInstance().getDeserializer(AuthorityRule.class);
    ParserConfig.getGlobalInstance().getDeserializer(ParamFlowRule.class);
}
 

@Bean
public Customizer<ReactiveSentinelCircuitBreakerFactory> slowCustomizer() {
	return factory -> {
		factory.configure(builder -> builder.rules(Collections.singletonList(
				new DegradeRule("slow_mono").setGrade(RuleConstant.DEGRADE_GRADE_RT)
						.setCount(100).setTimeWindow(5))),
				"slow_mono");
		factory.configure(builder -> builder.rules(Collections.singletonList(
				new DegradeRule("slow_flux").setGrade(RuleConstant.DEGRADE_GRADE_RT)
						.setCount(100).setTimeWindow(5))),
				"slow_flux");
		factory.configureDefault(id -> new SentinelConfigBuilder().resourceName(id)
				.rules(Collections.singletonList(new DegradeRule(id)
						.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT)
						.setCount(0.5).setTimeWindow(10)))
				.build());
	};
}
 

private void listenRules() throws Exception {
    ClassLoader classLoader = getClass().getClassLoader();
    String flowRulePath = URLDecoder.decode(classLoader.getResource("FlowRule.json").getFile(), "UTF-8");
    String degradeRulePath = URLDecoder.decode(classLoader.getResource("DegradeRule.json").getFile(), "UTF-8");
    String systemRulePath = URLDecoder.decode(classLoader.getResource("SystemRule.json").getFile(), "UTF-8");

    // Data source for FlowRule
    FileRefreshableDataSource<List<FlowRule>> flowRuleDataSource = new FileRefreshableDataSource<>(
        flowRulePath, flowRuleListParser);
    FlowRuleManager.register2Property(flowRuleDataSource.getProperty());

    // Data source for DegradeRule
    FileRefreshableDataSource<List<DegradeRule>> degradeRuleDataSource
        = new FileRefreshableDataSource<>(
        degradeRulePath, degradeRuleListParser);
    DegradeRuleManager.register2Property(degradeRuleDataSource.getProperty());

    // Data source for SystemRule
    FileRefreshableDataSource<List<SystemRule>> systemRuleDataSource
        = new FileRefreshableDataSource<>(
        systemRulePath, systemRuleListParser);
    SystemRuleManager.register2Property(systemRuleDataSource.getProperty());
}
 

private static void initDegradeRule() {
    List<DegradeRule> rules = new ArrayList<DegradeRule>();
    DegradeRule rule = new DegradeRule();
    rule.setResource(KEY);
    // set limit exception count to 4
    rule.setCount(4);
    rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
    /**
     * When degrading by {@link RuleConstant#DEGRADE_GRADE_EXCEPTION_COUNT}, time window
     * less than 60 seconds will not work as expected. Because the exception count is
     * summed by minute, when a short time window elapsed, the degradation condition
     * may still be satisfied.
     */
    rule.setTimeWindow(10);
    rules.add(rule);
    DegradeRuleManager.loadRules(rules);
}
 

@Test
public void testGetByClass() {
	assertThat(RuleType.getByClass(Object.class).isPresent())
			.isEqualTo(Boolean.FALSE);
	assertThat(RuleType.getByClass(AbstractRule.class).isPresent())
			.isEqualTo(Boolean.FALSE);
	assertThat(RuleType.getByClass(FlowRule.class).isPresent())
			.isEqualTo(Boolean.TRUE);
	assertThat(RuleType.getByClass(DegradeRule.class).isPresent())
			.isEqualTo(Boolean.TRUE);
	assertThat(RuleType.getByClass(ParamFlowRule.class).isPresent())
			.isEqualTo(Boolean.TRUE);
	assertThat(RuleType.getByClass(SystemRule.class).isPresent())
			.isEqualTo(Boolean.TRUE);
	assertThat(RuleType.getByClass(AuthorityRule.class).isPresent())
			.isEqualTo(Boolean.TRUE);
}
 

public List<DegradeRuleEntity> fetchDegradeRuleOfMachine(String app, String ip, int port) {
    List<DegradeRule> rules = fetchRules(ip, port, DEGRADE_RULE_TYPE, DegradeRule.class);
    if (rules != null) {
        return rules.stream().map(rule -> DegradeRuleEntity.fromDegradeRule(app, ip, port, rule))
            .collect(Collectors.toList());
    } else {
        return null;
    }
}
 

private void initDegradeRule(String resource) {
    DegradeRule degradeRule = new DegradeRule(resource)
            .setCount(0.5)
            .setGrade(DEGRADE_GRADE_EXCEPTION_RATIO);
    List<DegradeRule> degradeRules = new ArrayList<>();
    degradeRules.add(degradeRule);
    degradeRule.setTimeWindow(1);
    DegradeRuleManager.loadRules(degradeRules);
}
 

@Bean
public Customizer<SentinelCircuitBreakerFactory> defaultConfig() {
	return factory -> {
		factory.configureDefault(
				id -> new SentinelConfigBuilder().resourceName(id)
						.rules(Collections.singletonList(new DegradeRule(id)
								.setGrade(RuleConstant.DEGRADE_GRADE_RT).setCount(100)
								.setTimeWindow(10)))
						.build());
	};
}
 

public SentinelCircuitBreaker(String resourceName, EntryType entryType,
		List<DegradeRule> rules) {
	Assert.hasText(resourceName, "resourceName cannot be blank");
	Assert.notNull(rules, "rules should not be null");
	this.resourceName = resourceName;
	this.entryType = entryType;
	this.rules = Collections.unmodifiableList(rules);

	applyToSentinelRuleManager();
}
 

private void applyToSentinelRuleManager() {
	if (this.rules == null || this.rules.isEmpty()) {
		return;
	}
	Set<DegradeRule> ruleSet = new HashSet<>(DegradeRuleManager.getRules());
	for (DegradeRule rule : this.rules) {
		if (rule == null) {
			continue;
		}
		rule.setResource(resourceName);
		ruleSet.add(rule);
	}
	DegradeRuleManager.loadRules(new ArrayList<>(ruleSet));
}
 

public ReactiveSentinelCircuitBreaker(String resourceName, EntryType entryType,
		List<DegradeRule> rules) {
	Assert.hasText(resourceName, "resourceName cannot be blank");
	Assert.notNull(rules, "rules should not be null");
	this.resourceName = resourceName;
	this.entryType = entryType;
	this.rules = Collections.unmodifiableList(rules);

	applyToSentinelRuleManager();
}
 

private void applyToSentinelRuleManager() {
	if (this.rules == null || this.rules.isEmpty()) {
		return;
	}
	Set<DegradeRule> ruleSet = new HashSet<>(DegradeRuleManager.getRules());
	for (DegradeRule rule : this.rules) {
		if (rule == null) {
			continue;
		}
		rule.setResource(resourceName);
		ruleSet.add(rule);
	}
	DegradeRuleManager.loadRules(new ArrayList<>(ruleSet));
}
 

@Override
public SentinelCircuitBreakerConfiguration build() {
	Assert.hasText(resourceName, "resourceName cannot be empty");
	List<DegradeRule> rules = Optional.ofNullable(this.rules)
			.orElse(new ArrayList<>());

	EntryType entryType = Optional.ofNullable(this.entryType).orElse(EntryType.OUT);
	return new SentinelCircuitBreakerConfiguration()
			.setResourceName(this.resourceName).setEntryType(entryType)
			.setRules(rules);
}
 

public static DegradeRuleEntity fromDegradeRule(String app, String ip, Integer port, DegradeRule rule) {
    DegradeRuleEntity entity = new DegradeRuleEntity();
    entity.setApp(app);
    entity.setIp(ip);
    entity.setPort(port);
    entity.setResource(rule.getResource());
    entity.setLimitApp(rule.getLimitApp());
    entity.setCount(rule.getCount());
    entity.setTimeWindow(rule.getTimeWindow());
    entity.setGrade(rule.getGrade());
    return entity;
}
 

void onStart(@Observes StartupEvent ev) {
    LOGGER.info("The application is starting...");
    FlowRule rule = new FlowRule()
            .setCount(1)
            .setGrade(RuleConstant.FLOW_GRADE_QPS)
            .setResource("GET:/hello/txt")
            .setLimitApp("default")
            .as(FlowRule.class);
    FlowRuleManager.loadRules(Arrays.asList(rule));

    SystemRule systemRule = new SystemRule();
    systemRule.setLimitApp("default");
    systemRule.setAvgRt(3000);
    SystemRuleManager.loadRules(Arrays.asList(systemRule));

    DegradeRule degradeRule1 = new DegradeRule("greeting1")
            .setCount(1)
            .setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT)
            .setTimeWindow(10)
            .setMinRequestAmount(1);

    DegradeRule degradeRule2 = new DegradeRule("greeting2")
            .setCount(1)
            .setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT)
            .setTimeWindow(10)
            .setMinRequestAmount(1);
    DegradeRuleManager.loadRules(Arrays.asList(degradeRule1, degradeRule2));
}
 

public static void initExceptionFallback(int timewindow) {
    DegradeRule degradeRule = new DegradeRule(INTERFACE_RES_KEY)
            .setCount(0.5)
            .setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO)
            .setTimeWindow(timewindow)
            .setMinRequestAmount(1);
    DegradeRuleManager.loadRules(Collections.singletonList(degradeRule));

}
 

private static void initDegradeRule() {
    List<DegradeRule> rules = new ArrayList<DegradeRule>();
    DegradeRule rule = new DegradeRule();
    rule.setResource(KEY);
    // set threshold rt, 10 ms
    rule.setCount(10);
    rule.setGrade(RuleConstant.DEGRADE_GRADE_RT);
    rule.setTimeWindow(10);
    rules.add(rule);
    DegradeRuleManager.loadRules(rules);
}
 

private static void initDegradeRule() {
    List<DegradeRule> rules = new ArrayList<DegradeRule>();
    DegradeRule rule = new DegradeRule();
    rule.setResource(KEY);
    // set limit exception ratio to 0.1
    rule.setCount(0.1);
    rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO);
    rule.setTimeWindow(10);
    rule.setMinRequestAmount(20);
    rules.add(rule);
    DegradeRuleManager.loadRules(rules);
}
 

private static void initDegradeRule() {
    List<DegradeRule> rules = new ArrayList<DegradeRule>();
    DegradeRule rule = new DegradeRule();
    rule.setResource(KEY);
    // set limit exception ratio to 0.1
    rule.setCount(0.1);
    rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO);
    rule.setTimeWindow(10);
    rule.setMinRequestAmount(20);
    rules.add(rule);
    DegradeRuleManager.loadRules(rules);
}
 

@Override
public DegradeRule toRule() {
    DegradeRule rule = new DegradeRule();
    rule.setResource(resource);
    rule.setLimitApp(limitApp);
    rule.setCount(count);
    rule.setTimeWindow(timeWindow);
    rule.setGrade(grade);
    return rule;
}
 

public List<DegradeRuleEntity> fetchDegradeRuleOfMachine(String app, String ip, int port) {
    List<DegradeRule> rules = fetchRules(ip, port, DEGRADE_RULE_TYPE, DegradeRule.class);
    if (rules != null) {
        return rules.stream().map(rule -> DegradeRuleEntity.fromDegradeRule(app, ip, port, rule))
            .collect(Collectors.toList());
    } else {
        return null;
    }
}
 

@Override
public DegradeRule toRule() {
    DegradeRule rule = new DegradeRule();
    rule.setResource(resource);
    rule.setLimitApp(limitApp);
    rule.setCount(count);
    rule.setTimeWindow(timeWindow);
    rule.setGrade(grade);
    return rule;
}
 

private static void initDegradeRule() {
    List<DegradeRule> rules = new ArrayList<DegradeRule>();
    DegradeRule rule = new DegradeRule();
    rule.setResource(KEY);
    // set threshold rt, 10 ms
    rule.setCount(10);
    rule.setGrade(RuleConstant.DEGRADE_GRADE_RT);
    rule.setTimeWindow(10);
    rules.add(rule);
    DegradeRuleManager.loadRules(rules);
}
 

public static DegradeRuleEntity fromDegradeRule(String app, String ip, Integer port, DegradeRule rule) {
    DegradeRuleEntity entity = new DegradeRuleEntity();
    entity.setApp(app);
    entity.setIp(ip);
    entity.setPort(port);
    entity.setResource(rule.getResource());
    entity.setLimitApp(rule.getLimitApp());
    entity.setCount(rule.getCount());
    entity.setTimeWindow(rule.getTimeWindow());
    entity.setGrade(rule.getGrade());
    return entity;
}